@enbox/dwn-sdk-js 0.0.6 → 0.0.8

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

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { ArrayUtility } from '../../src/utils/array.js';
 import { createLevelDatabase } from '../../src/store/level-wrapper.js';
 import { DwnErrorCode } from '../../src/index.js';
@@ -21,59 +12,59 @@ describe('IndexLevel', () => {
     let testIndex;
     const tenant = 'did:alice:index-test';
     describe('put', () => {
-        beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+        beforeAll(async () => {
             testIndex = new IndexLevel({
                 createLevelDatabase,
                 location: 'TEST-INDEX',
             });
-            yield testIndex.open();
-        }));
-        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield testIndex.clear();
-        }));
-        afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield testIndex.close();
-        }));
+            await testIndex.open();
+        });
+        beforeEach(async () => {
+            await testIndex.clear();
+        });
+        afterAll(async () => {
+            await testIndex.close();
+        });
         describe('fails to index with no indexable properties', () => {
-            it('fails on empty indexes', () => __awaiter(void 0, void 0, void 0, function* () {
+            it('fails on empty indexes', async () => {
                 const id = uuid();
                 const failedIndexPromise = testIndex.put(tenant, id, {});
-                yield expect(failedIndexPromise).rejects.toThrow(DwnErrorCode.IndexMissingIndexableProperty);
-            }));
+                await expect(failedIndexPromise).rejects.toThrow(DwnErrorCode.IndexMissingIndexableProperty);
+            });
         });
-        it('successfully indexes', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('successfully indexes', async () => {
             const id = uuid();
-            yield testIndex.put(tenant, id, {
+            await testIndex.put(tenant, id, {
                 id,
                 foo: 'foo',
                 digit: 12,
                 toggle: false,
                 tag: ['bar', 'baz']
             });
-            const results = yield testIndex.query(tenant, [{ id: id }], { sortProperty: 'id' });
+            const results = await testIndex.query(tenant, [{ id: id }], { sortProperty: '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* () {
+        });
+        it('adds one index key per property value, aside from id', async () => {
             const id = uuid(); // 1 key for reverse lookup
             const dateCreated = new Date().toISOString();
-            yield testIndex.put(tenant, id, {
+            await testIndex.put(tenant, id, {
                 'a': 'b', // 1 key
                 'c': ['d', 'e'], // 2 key
                 dateCreated, // 1 key
             });
-            let keys = yield ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
+            let keys = await ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
             expect(keys.length).toBe(5);
-            yield testIndex.clear();
-            yield testIndex.put(tenant, id, {
+            await testIndex.clear();
+            await testIndex.put(tenant, id, {
                 'a': 'b', // 1 key
                 'c': ['d', 'e'], // 2 keys
                 'f': 'g', // 1 key
                 dateCreated, // 1 key
             });
-            keys = yield ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
+            keys = await ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
             expect(keys.length).toBe(6);
-        }));
-        it('should not put anything if aborted beforehand', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('should not put anything if aborted beforehand', async () => {
             const controller = new AbortController();
             controller.abort('reason');
             const id = uuid();
@@ -82,26 +73,26 @@ describe('IndexLevel', () => {
                 foo: 'bar'
             };
             const indexPromise = testIndex.put(tenant, id, index, { signal: controller.signal });
-            yield expect(indexPromise).rejects.toThrow('reason');
-            const entries = yield testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
+            await expect(indexPromise).rejects.toThrow('reason');
+            const entries = await testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
             expect(entries.length).toBe(0);
-        }));
+        });
     });
     describe('query', () => {
-        beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+        beforeAll(async () => {
             testIndex = new IndexLevel({
                 createLevelDatabase,
                 location: 'TEST-INDEX',
             });
-            yield testIndex.open();
-        }));
-        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield testIndex.clear();
-        }));
-        afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield testIndex.close();
-        }));
-        it('works', () => __awaiter(void 0, void 0, void 0, function* () {
+            await testIndex.open();
+        });
+        beforeEach(async () => {
+            await testIndex.clear();
+        });
+        afterAll(async () => {
+            await testIndex.close();
+        });
+        it('works', async () => {
             const id1 = uuid();
             const doc1 = {
                 id: id1,
@@ -120,106 +111,106 @@ describe('IndexLevel', () => {
                 'a': 'b',
                 'c': 'e'
             };
-            yield testIndex.put(tenant, id1, doc1);
-            yield testIndex.put(tenant, id2, doc2);
-            yield testIndex.put(tenant, id3, doc3);
-            const entries = yield testIndex.query(tenant, [{
+            await testIndex.put(tenant, id1, doc1);
+            await testIndex.put(tenant, id2, doc2);
+            await testIndex.put(tenant, id3, doc3);
+            const entries = await testIndex.query(tenant, [{
                     'a': 'b',
                     'c': 'e'
                 }], { sortProperty: 'id' });
             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* () {
+        });
+        it('should return all records if an empty filter array is passed', async () => {
             const items = ['b', 'a', 'd', 'c'];
             for (const item of items) {
-                yield testIndex.put(tenant, item, { letter: item, index: items.indexOf(item) });
+                await testIndex.put(tenant, item, { letter: item, index: items.indexOf(item) });
             }
             // empty array
-            let allResults = yield testIndex.query(tenant, [], { sortProperty: 'letter' });
+            let allResults = await testIndex.query(tenant, [], { sortProperty: 'letter' });
             expect(allResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b', 'c', 'd']);
             // empty filter
-            allResults = yield testIndex.query(tenant, [{}], { sortProperty: 'letter' });
+            allResults = await testIndex.query(tenant, [{}], { sortProperty: 'letter' });
             expect(allResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b', 'c', 'd']);
-        }));
+        });
         describe('queryWithIteratorPaging()', () => {
-            it('paginates using cursor', () => __awaiter(void 0, void 0, void 0, function* () {
+            it('paginates using cursor', async () => {
                 const testVals = ['b', 'd', 'c', 'a'];
                 for (const val of testVals) {
-                    yield testIndex.put(tenant, val, { val, schema: 'schema', published: true });
+                    await testIndex.put(tenant, val, { val, schema: 'schema', published: true });
                 }
                 // insert other records to be filtered out
                 for (const val of testVals) {
                     const otherVal = val + val;
-                    yield testIndex.put(tenant, otherVal, { val: otherVal, schema: 'schema', published: false });
+                    await testIndex.put(tenant, otherVal, { val: otherVal, schema: 'schema', published: false });
                 }
                 const filters = [{ schema: 'schema', published: true }];
                 // query with limit, default (ascending)
-                const results = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
+                const results = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
                 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') });
+                const resultsAfterCursor = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(results, 'val') });
                 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 });
+                const ascResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
                 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') });
+                const ascResultsAfterCursor = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(ascResults, 'val') });
                 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 });
+                const descResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', limit: 2 });
                 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') });
+                const descResultsAfterCursor = await testIndex.queryWithIteratorPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(descResults, 'val') });
                 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* () {
+            });
+            it('returns empty array if sort property is invalid', async () => {
                 const testVals = ['b', 'd', 'c', 'a'];
                 for (const val of testVals) {
-                    yield testIndex.put(tenant, val, { val, schema: 'schema', published: true });
+                    await testIndex.put(tenant, val, { val, schema: 'schema', published: true });
                 }
                 // insert other records to be filtered out
                 for (const val of testVals) {
                     const otherVal = val + val;
-                    yield testIndex.put(tenant, otherVal, { val: otherVal, schema: 'schema', published: false });
+                    await testIndex.put(tenant, otherVal, { val: otherVal, schema: 'schema', published: false });
                 }
                 const filters = [{ schema: 'schema', published: true }];
                 // control test: return all results
-                const validResults = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val' });
+                const validResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val' });
                 expect(validResults.length).toBe(4);
                 // sort by invalid property returns no results
-                const invalidResults = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'invalid' });
+                const invalidResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'invalid' });
                 expect(invalidResults.length).toBe(0);
-            }));
-            it('cursor is valid but out of range of matched results', () => __awaiter(void 0, void 0, void 0, function* () {
+            });
+            it('cursor is valid but out of range of matched results', async () => {
                 const testVals = ['b', 'd', 'c']; // a is missing
                 for (const val of testVals) {
-                    yield testIndex.put(tenant, `${val}-id`, { val, schema: 'schema', published: true });
+                    await testIndex.put(tenant, `${val}-id`, { val, schema: 'schema', published: true });
                 }
                 // insert other records to be filtered out
                 for (const val of testVals) {
                     const otherVal = val + val;
-                    yield testIndex.put(tenant, `${val}-id`, { val: otherVal, schema: 'schema', published: false });
+                    await testIndex.put(tenant, `${val}-id`, { val: otherVal, schema: 'schema', published: false });
                 }
                 const filters = [{ schema: 'schema', published: true }];
                 // 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 });
+                const allResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: cursorA });
                 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 });
+                const noResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: cursorE });
                 expect(noResults.length).toEqual(0);
-            }));
+            });
         });
         describe('array values', () => {
-            it('query items with string array values', () => __awaiter(void 0, void 0, void 0, function* () {
+            it('query items with string array values', async () => {
                 const items = [{
                         id: uuid(),
                         tag: ['item1', 'item']
@@ -234,18 +225,18 @@ describe('IndexLevel', () => {
                         tag: ['item4', 'item']
                     }];
                 for (const item of items) {
-                    yield testIndex.put(tenant, item.id, item);
+                    await testIndex.put(tenant, item.id, item);
                 }
                 const filterForItemTag = [{ tag: 'item' }];
-                const allResults = yield testIndex.queryWithIteratorPaging(tenant, filterForItemTag, { sortProperty: 'id' });
+                const allResults = await testIndex.queryWithIteratorPaging(tenant, filterForItemTag, { sortProperty: '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' });
+                const item3Results = await testIndex.queryWithIteratorPaging(tenant, filterForItem3, { sortProperty: '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* () {
+            });
+            it('query items with number array values', async () => {
                 const items = [{
                         id: uuid(),
                         tag: [1]
@@ -260,121 +251,121 @@ describe('IndexLevel', () => {
                         tag: [1, 4]
                     }];
                 for (const item of items) {
-                    yield testIndex.put(tenant, item.id, item);
+                    await testIndex.put(tenant, item.id, item);
                 }
                 const filterForItemTag = [{ tag: 1 }];
-                const allResults = yield testIndex.queryWithIteratorPaging(tenant, filterForItemTag, { sortProperty: 'id' });
+                const allResults = await testIndex.queryWithIteratorPaging(tenant, filterForItemTag, { sortProperty: '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' });
+                const item3Results = await testIndex.queryWithIteratorPaging(tenant, filterForItem3, { sortProperty: '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' });
+                const rangeItems = await testIndex.queryWithIteratorPaging(tenant, filterForRange, { sortProperty: 'id' });
                 expect(rangeItems.length).toBe(2);
                 expect(rangeItems.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[1].id, items[2].id]));
-            }));
+            });
         });
         describe('queryWithInMemoryPaging()', () => {
-            it('paginates using cursor', () => __awaiter(void 0, void 0, void 0, function* () {
+            it('paginates using cursor', async () => {
                 const testVals = ['b', 'd', 'c', 'a'];
                 for (const val of testVals) {
-                    yield testIndex.put(tenant, val, { val, schema: 'schema', published: true });
+                    await testIndex.put(tenant, val, { val, schema: 'schema', published: true });
                 }
                 // insert other records to be filtered out
                 for (const val of testVals) {
                     const otherVal = val + val;
-                    yield testIndex.put(tenant, otherVal, { val: otherVal, schema: 'schema', published: false });
+                    await testIndex.put(tenant, otherVal, { val: otherVal, schema: 'schema', published: false });
                 }
                 const filters = [{ schema: 'schema', published: true }];
                 // query with limit, default (ascending)
-                const results = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
+                const results = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
                 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') });
+                const resultsAfterCursor = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(results, 'val') });
                 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 });
+                const ascResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
                 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') });
+                const ascResultsAfterCursor = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(ascResults, 'val') });
                 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 });
+                const descResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', limit: 2 });
                 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') });
+                const descResultsAfterCursor = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(descResults, 'val') });
                 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* () {
+            });
+            it('returns empty array if sort property is invalid', async () => {
                 const testVals = ['b', 'd', 'c', 'a'];
                 for (const val of testVals) {
-                    yield testIndex.put(tenant, val, { val, schema: 'schema', published: true });
+                    await testIndex.put(tenant, val, { val, schema: 'schema', published: true });
                 }
                 // insert other records to be filtered out
                 for (const val of testVals) {
                     const otherVal = val + val;
-                    yield testIndex.put(tenant, otherVal, { val: otherVal, schema: 'schema', published: false });
+                    await testIndex.put(tenant, otherVal, { val: otherVal, schema: 'schema', published: false });
                 }
                 const filters = [{ schema: 'schema', published: true }];
                 // control test: return all results
-                const validResults = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 3 });
+                const validResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 3 });
                 expect(validResults.length).toBe(3);
                 // sort by invalid property returns no results
-                const invalidResults = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'invalid' });
+                const invalidResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'invalid' });
                 expect(invalidResults.length).toBe(0);
-            }));
-            it('cursor is valid but out of range of matched results', () => __awaiter(void 0, void 0, void 0, function* () {
+            });
+            it('cursor is valid but out of range of matched results', async () => {
                 const testVals = ['b', 'd', 'c', 'a'];
                 for (const val of testVals) {
-                    yield testIndex.put(tenant, val, { val, schema: 'schema', published: true });
+                    await testIndex.put(tenant, val, { val, schema: 'schema', published: true });
                 }
                 // insert other records to be filtered out
                 for (const val of testVals) {
                     const otherVal = val + val;
-                    yield testIndex.put(tenant, otherVal, { val: otherVal, schema: 'schema', published: false });
+                    await testIndex.put(tenant, otherVal, { val: otherVal, schema: 'schema', published: false });
                 }
                 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 });
+                const allResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: cursorA });
                 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 });
+                const noResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: cursorE });
                 expect(noResults.length).toEqual(0);
-            }));
-            it('supports range queries', () => __awaiter(void 0, void 0, void 0, function* () {
+            });
+            it('supports range queries', async () => {
                 const id = uuid();
                 const doc1 = {
                     id,
                     value: 'foo'
                 };
-                yield testIndex.put(tenant, id, doc1);
+                await testIndex.put(tenant, id, doc1);
                 const id2 = uuid();
                 const doc2 = {
                     id: id2,
                     value: 'foobar'
                 };
-                yield testIndex.put(tenant, id2, doc2);
+                await testIndex.put(tenant, id2, doc2);
                 const id3 = uuid();
                 const doc3 = {
                     id: id3,
                     value: 'foobaz'
                 };
-                yield testIndex.put(tenant, id3, doc3);
+                await testIndex.put(tenant, id3, doc3);
                 const filters = [{
                         value: {
                             gt: 'foo',
                             lte: 'foobaz'
                         }
                     }];
-                const entries = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'id' });
+                const entries = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'id' });
                 expect(entries.length).toBe(2);
                 expect(entries.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([id2, id3]));
                 // only upper bounds
@@ -383,12 +374,12 @@ describe('IndexLevel', () => {
                             lte: 'foobaz'
                         }
                     }];
-                const lteReply = yield testIndex.queryWithInMemoryPaging(tenant, lteFilter, { sortProperty: 'id' });
+                const lteReply = await testIndex.queryWithInMemoryPaging(tenant, lteFilter, { sortProperty: 'id' });
                 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* () {
+                it('query items with string array values', async () => {
                     const items = [{
                             id: uuid(),
                             tag: ['item1', 'item']
@@ -403,18 +394,18 @@ describe('IndexLevel', () => {
                             tag: ['item4', 'item']
                         }];
                     for (const item of items) {
-                        yield testIndex.put(tenant, item.id, item);
+                        await testIndex.put(tenant, item.id, item);
                     }
                     const filterForItemTag = [{ tag: 'item' }];
-                    const allResults = yield testIndex.queryWithInMemoryPaging(tenant, filterForItemTag, { sortProperty: 'id' });
+                    const allResults = await testIndex.queryWithInMemoryPaging(tenant, filterForItemTag, { sortProperty: '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' });
+                    const item3Results = await testIndex.queryWithInMemoryPaging(tenant, filterForItem3, { sortProperty: '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* () {
+                });
+                it('query items with number array values', async () => {
                     const items = [{
                             id: uuid(),
                             tag: [1]
@@ -429,36 +420,36 @@ describe('IndexLevel', () => {
                             tag: [1, 4]
                         }];
                     for (const item of items) {
-                        yield testIndex.put(tenant, item.id, item);
+                        await testIndex.put(tenant, item.id, item);
                     }
                     const filterForItemTag = [{ tag: 1 }];
-                    const allResults = yield testIndex.queryWithInMemoryPaging(tenant, filterForItemTag, { sortProperty: 'id' });
+                    const allResults = await testIndex.queryWithInMemoryPaging(tenant, filterForItemTag, { sortProperty: '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' });
+                    const item3Results = await testIndex.queryWithInMemoryPaging(tenant, filterForItem3, { sortProperty: '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' });
+                    const rangeItems = await testIndex.queryWithInMemoryPaging(tenant, filterForRange, { sortProperty: 'id' });
                     expect(rangeItems.length).toBe(2);
                     expect(rangeItems.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[1].id, items[2].id]));
-                }));
+                });
             });
         });
         describe('query()', () => {
-            it('should not match values prefixed with the query', () => __awaiter(void 0, void 0, void 0, function* () {
+            it('should not match values prefixed with the query', async () => {
                 const id = uuid();
                 const doc = {
                     id,
                     value: 'foobar'
                 };
-                yield testIndex.put(tenant, id, doc);
+                await testIndex.put(tenant, id, doc);
                 const filters = [{ value: 'foo' }];
-                const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
+                const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
                 expect(entries.length).toBe(0);
-            }));
-            it('supports OR queries', () => __awaiter(void 0, void 0, void 0, function* () {
+            });
+            it('supports OR queries', async () => {
                 const id1 = uuid();
                 const doc1 = {
                     id: id1,
@@ -474,51 +465,51 @@ describe('IndexLevel', () => {
                     id: id3,
                     'a': 'c'
                 };
-                yield testIndex.put(tenant, id1, doc1);
-                yield testIndex.put(tenant, id2, doc2);
-                yield testIndex.put(tenant, id3, doc3);
+                await testIndex.put(tenant, id1, doc1);
+                await testIndex.put(tenant, id2, doc2);
+                await testIndex.put(tenant, id3, doc3);
                 const filters = [{
                         a: ['a', 'b']
                     }];
-                const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
+                const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
                 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* () {
+            });
+            it('supports range queries', async () => {
                 for (let i = -5; i < 5; ++i) {
                     const id = uuid();
                     const doc = {
                         id,
                         dateCreated: Temporal.PlainDateTime.from({ year: 2023, month: 1, day: 15 + i }).toString({ smallestUnit: 'microseconds' })
                     };
-                    yield testIndex.put(tenant, id, doc);
+                    await testIndex.put(tenant, id, doc);
                 }
                 const filters = [{
                         dateCreated: {
                             gte: Temporal.PlainDateTime.from({ year: 2023, month: 1, day: 15 }).toString({ smallestUnit: 'microseconds' })
                         }
                     }];
-                const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
+                const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
                 expect(entries.length).toBe(5);
-            }));
-            it('supports prefixed range queries', () => __awaiter(void 0, void 0, void 0, function* () {
+            });
+            it('supports prefixed range queries', async () => {
                 const id = uuid();
                 const doc = {
                     id,
                     value: 'foobar'
                 };
-                yield testIndex.put(tenant, id, doc);
+                await testIndex.put(tenant, id, doc);
                 const filters = [{
                         value: {
                             gte: 'foo'
                         }
                     }];
-                const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
+                const entries = await testIndex.query(tenant, filters, { sortProperty: '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* () {
+            });
+            it('supports suffixed range queries', async () => {
                 const id1 = uuid();
                 const doc1 = {
                     id: id1,
@@ -529,18 +520,18 @@ describe('IndexLevel', () => {
                     id: id2,
                     foo: 'barbaz'
                 };
-                yield testIndex.put(tenant, id1, doc1);
-                yield testIndex.put(tenant, id2, doc2);
+                await testIndex.put(tenant, id1, doc1);
+                await testIndex.put(tenant, id2, doc2);
                 const filters = [{
                         foo: {
                             lte: 'bar'
                         }
                     }];
-                const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
+                const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
                 expect(entries.length).toBe(1);
                 expect(entries.map(({ messageCid }) => messageCid)).toContain(id1);
-            }));
-            it('treats strings differently', () => __awaiter(void 0, void 0, void 0, function* () {
+            });
+            it('treats strings differently', async () => {
                 const id1 = uuid();
                 const doc1 = {
                     id: id1,
@@ -551,44 +542,43 @@ describe('IndexLevel', () => {
                     id: id2,
                     foo: 'true'
                 };
-                yield testIndex.put(tenant, id1, doc1);
-                yield testIndex.put(tenant, id2, doc2);
+                await testIndex.put(tenant, id1, doc1);
+                await testIndex.put(tenant, id2, doc2);
                 const filters = [{
                         foo: true
                     }];
-                const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
+                const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
                 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);
                 const negativeDigits = Array(10).fill({}).map(_ => TestDataGenerator.randomInt(0, Number.MAX_SAFE_INTEGER) * -1).sort((a, b) => a - b);
                 const testNumbers = Array.from(new Set([...negativeDigits, ...positiveDigits])); // unique numbers
-                it('should return records that match provided number equality filter', () => __awaiter(void 0, void 0, void 0, function* () {
-                    var _a;
+                it('should return records that match provided number equality filter', async () => {
                     const index = Math.floor(Math.random() * testNumbers.length);
                     for (const digit of testNumbers) {
-                        yield testIndex.put(tenant, digit.toString(), { digit });
+                        await testIndex.put(tenant, digit.toString(), { digit });
                     }
                     const filters = [{
                             digit: testNumbers.at(index)
                         }];
-                    const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
+                    const entries = await testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     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* () {
+                    expect(entries.at(0)?.messageCid).toBe(testNumbers.at(index).toString());
+                });
+                it('should not return records that do not match provided number equality filter', async () => {
                     // remove the potential (but unlikely) negative test result
                     for (const digit of testNumbers.filter(n => n !== 1)) {
-                        yield testIndex.put(tenant, digit.toString(), { digit });
+                        await testIndex.put(tenant, digit.toString(), { digit });
                     }
                     const filters = [{ digit: 1 }];
-                    const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
+                    const entries = await testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     expect(entries.length).toBe(0);
-                }));
-                it('supports range queries with positive numbers inclusive', () => __awaiter(void 0, void 0, void 0, function* () {
+                });
+                it('supports range queries with positive numbers inclusive', async () => {
                     for (const digit of testNumbers) {
-                        yield testIndex.put(tenant, digit.toString(), { digit });
+                        await testIndex.put(tenant, digit.toString(), { digit });
                     }
                     const upperBound = positiveDigits.at(positiveDigits.length - 3);
                     const lowerBound = positiveDigits.at(2);
@@ -598,13 +588,13 @@ describe('IndexLevel', () => {
                                 lte: upperBound
                             }
                         }];
-                    const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
+                    const entries = await testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n >= lowerBound && n <= upperBound).map(n => n.toString());
                     expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
-                }));
-                it('supports range queries with negative numbers inclusive', () => __awaiter(void 0, void 0, void 0, function* () {
+                });
+                it('supports range queries with negative numbers inclusive', async () => {
                     for (const digit of testNumbers) {
-                        yield testIndex.put(tenant, digit.toString(), { digit });
+                        await testIndex.put(tenant, digit.toString(), { digit });
                     }
                     const upperBound = negativeDigits.at(negativeDigits.length - 2);
                     const lowerBound = negativeDigits.at(2);
@@ -614,13 +604,13 @@ describe('IndexLevel', () => {
                                 lte: upperBound
                             }
                         }];
-                    const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
+                    const entries = await testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n >= lowerBound && n <= upperBound).map(n => n.toString());
                     expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
-                }));
-                it('should return numbers gt a negative digit', () => __awaiter(void 0, void 0, void 0, function* () {
+                });
+                it('should return numbers gt a negative digit', async () => {
                     for (const digit of testNumbers) {
-                        yield testIndex.put(tenant, digit.toString(), { digit });
+                        await testIndex.put(tenant, digit.toString(), { digit });
                     }
                     const lowerBound = negativeDigits.at(4);
                     const filters = [{
@@ -628,13 +618,13 @@ describe('IndexLevel', () => {
                                 gt: lowerBound,
                             }
                         }];
-                    const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
+                    const entries = await testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n > lowerBound).map(n => n.toString());
                     expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
-                }));
-                it('should return numbers gt a digit', () => __awaiter(void 0, void 0, void 0, function* () {
+                });
+                it('should return numbers gt a digit', async () => {
                     for (const digit of testNumbers) {
-                        yield testIndex.put(tenant, digit.toString(), { digit });
+                        await testIndex.put(tenant, digit.toString(), { digit });
                     }
                     const lowerBound = positiveDigits.at(4);
                     const filters = [{
@@ -642,13 +632,13 @@ describe('IndexLevel', () => {
                                 gt: lowerBound,
                             }
                         }];
-                    const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
+                    const entries = await testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n > lowerBound).map(n => n.toString());
                     expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
-                }));
-                it('should return numbers lt a negative digit', () => __awaiter(void 0, void 0, void 0, function* () {
+                });
+                it('should return numbers lt a negative digit', async () => {
                     for (const digit of testNumbers) {
-                        yield testIndex.put(tenant, digit.toString(), { digit });
+                        await testIndex.put(tenant, digit.toString(), { digit });
                     }
                     const upperBound = negativeDigits.at(4);
                     const filters = [{
@@ -656,13 +646,13 @@ describe('IndexLevel', () => {
                                 lt: upperBound,
                             }
                         }];
-                    const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
+                    const entries = await testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n < upperBound).map(n => n.toString());
                     expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
-                }));
-                it('should return numbers lt a digit', () => __awaiter(void 0, void 0, void 0, function* () {
+                });
+                it('should return numbers lt a digit', async () => {
                     for (const digit of testNumbers) {
-                        yield testIndex.put(tenant, digit.toString(), { digit });
+                        await testIndex.put(tenant, digit.toString(), { digit });
                     }
                     const upperBound = positiveDigits.at(4);
                     const filters = [{
@@ -670,117 +660,117 @@ describe('IndexLevel', () => {
                                 lt: upperBound,
                             }
                         }];
-                    const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
+                    const entries = await testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n < upperBound).map(n => n.toString());
                     expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
-                }));
+                });
             });
             describe('booleans', () => {
-                it('should return records that match provided boolean equality filter', () => __awaiter(void 0, void 0, void 0, function* () {
+                it('should return records that match provided boolean equality filter', async () => {
                     const itemTrueId = uuid();
                     const boolTrueItem = {
                         id: itemTrueId,
                         schema: 'schema',
                         published: true,
                     };
-                    yield testIndex.put(tenant, itemTrueId, boolTrueItem);
+                    await testIndex.put(tenant, itemTrueId, boolTrueItem);
                     const itemFalseId = uuid();
                     const boolFalseItem = {
                         id: itemFalseId,
                         schema: 'schema',
                         published: false,
                     };
-                    yield testIndex.put(tenant, itemFalseId, boolFalseItem);
+                    await testIndex.put(tenant, itemFalseId, boolFalseItem);
                     const bothFilter = [{ schema: 'schema' }];
                     // control
-                    const entries = yield testIndex.query(tenant, bothFilter, { sortProperty: 'id' });
+                    const entries = await testIndex.query(tenant, bothFilter, { sortProperty: 'id' });
                     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' });
+                    const respTrue = await testIndex.query(tenant, trueFilter, { sortProperty: 'id' });
                     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' });
+                    const respFalse = await testIndex.query(tenant, falseFilter, { sortProperty: 'id' });
                     expect(respFalse.length).toBe(1);
                     expect(respFalse.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([itemFalseId]));
-                }));
+                });
             });
             describe('sort, limit and cursor', () => {
-                it('only returns the number of results specified by the limit property', () => __awaiter(void 0, void 0, void 0, function* () {
+                it('only returns the number of results specified by the limit property', async () => {
                     const testVals = ['b', 'a', 'd', 'c'];
                     for (const val of testVals) {
-                        yield testIndex.put(tenant, val, { val, schema: 'schema' });
+                        await testIndex.put(tenant, val, { val, schema: 'schema' });
                     }
                     const filters = [{ schema: 'schema' }];
                     // limit results without cursor
-                    let ascResults = yield testIndex.query(tenant, filters, { sortProperty: 'val', limit: 2 });
+                    let ascResults = await testIndex.query(tenant, filters, { sortProperty: 'val', limit: 2 });
                     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') });
+                    ascResults = await testIndex.query(tenant, filters, { sortProperty: 'val', limit: 2, cursor: IndexLevel.createCursorFromLastArrayItem(ascResults, 'val') });
                     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* () {
+                });
+                it('can sort by any indexed property', async () => {
                     const testVals = ['b', 'd', 'c', 'a'];
                     for (const val of testVals) {
-                        yield testIndex.put(tenant, val, { val, schema: 'schema', index: testVals.indexOf(val) });
+                        await testIndex.put(tenant, val, { val, schema: 'schema', index: testVals.indexOf(val) });
                     }
                     const filters = [{ schema: 'schema' }];
                     // sort by value ascending
-                    const ascResults = yield testIndex.query(tenant, filters, { sortProperty: 'val' });
+                    const ascResults = await testIndex.query(tenant, filters, { sortProperty: 'val' });
                     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' });
+                    const ascIndexResults = await testIndex.query(tenant, filters, { sortProperty: 'index' });
                     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 });
+                    const descResults = await testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending });
                     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 });
+                    const descIndexResults = await testIndex.query(tenant, filters, { sortProperty: 'index', sortDirection: SortDirection.Descending });
                     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* () {
+                });
+                it('sorts lexicographic', async () => {
                     const testVals = ['b', 'a', 'd', 'c'];
                     for (const val of testVals) {
-                        yield testIndex.put(tenant, val, { val, schema: 'schema' });
+                        await testIndex.put(tenant, val, { val, schema: 'schema' });
                     }
                     const filters = [{ schema: 'schema' }];
                     // sort ascending
-                    const ascResults = yield testIndex.query(tenant, filters, { sortProperty: 'val' });
+                    const ascResults = await testIndex.query(tenant, filters, { sortProperty: 'val' });
                     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 });
+                    const descResults = await testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending });
                     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* () {
+                });
+                it('sorts numeric with and without a cursor', async () => {
                     const testVals = [-2, -1, 0, 1, 2, 3, 4];
                     for (const val of testVals) {
-                        yield testIndex.put(tenant, val.toString(), { val, schema: 'schema' });
+                        await testIndex.put(tenant, val.toString(), { val, schema: 'schema' });
                     }
                     const filters = [{ schema: 'schema' }];
                     // sort ascending
-                    const ascResults = yield testIndex.query(tenant, filters, { sortProperty: 'val' });
+                    const ascResults = await testIndex.query(tenant, filters, { sortProperty: 'val' });
                     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 });
+                    const descResults = await testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending });
                     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* () {
+                });
+                it('sorts range queries with or without a cursor', async () => {
                     const testItems = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
                     for (const item of testItems) {
-                        yield testIndex.put(tenant, item, { letter: item });
+                        await testIndex.put(tenant, item, { letter: item });
                     }
                     // test both upper and lower bounds
                     const lowerBound = 'b';
@@ -792,16 +782,16 @@ describe('IndexLevel', () => {
                             },
                         }];
                     // ascending without a cursor
-                    let response = yield testIndex.query(tenant, bothBoundsFilters, { sortProperty: 'letter', limit: 4 });
+                    let response = await testIndex.query(tenant, bothBoundsFilters, { sortProperty: 'letter', limit: 4 });
                     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') });
+                    response = await testIndex.query(tenant, bothBoundsFilters, { sortProperty: 'letter', cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
                     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 });
+                    response = await testIndex.query(tenant, bothBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, limit: 4 });
                     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') });
+                    response = await testIndex.query(tenant, bothBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
                     expect(response.map(({ messageCid }) => messageCid)).toEqual(['c', 'b']); // should only return less than d
                     // test only upper bounds
                     const upperBoundsFilters = [{
@@ -810,16 +800,16 @@ describe('IndexLevel', () => {
                             },
                         }];
                     // ascending without a cursor
-                    response = yield testIndex.query(tenant, upperBoundsFilters, { sortProperty: 'letter', limit: 4 });
+                    response = await testIndex.query(tenant, upperBoundsFilters, { sortProperty: 'letter', limit: 4 });
                     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') });
+                    response = await testIndex.query(tenant, upperBoundsFilters, { sortProperty: 'letter', cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
                     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 });
+                    response = await testIndex.query(tenant, upperBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, limit: 4 });
                     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') });
+                    response = await testIndex.query(tenant, upperBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
                     expect(response.map(({ messageCid }) => messageCid)).toEqual(['c', 'b', 'a']); // should only return items less than c
                     // test only lower bounds
                     const lowerBoundsFilters = [{
@@ -828,22 +818,22 @@ describe('IndexLevel', () => {
                             },
                         }];
                     // ascending without a cursor
-                    response = yield testIndex.query(tenant, lowerBoundsFilters, { sortProperty: 'letter', limit: 4 });
+                    response = await testIndex.query(tenant, lowerBoundsFilters, { sortProperty: 'letter', limit: 4 });
                     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') });
+                    response = await testIndex.query(tenant, lowerBoundsFilters, { sortProperty: 'letter', cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
                     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 });
+                    response = await testIndex.query(tenant, lowerBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, limit: 4 });
                     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') });
+                    response = await testIndex.query(tenant, lowerBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
                     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* () {
+                });
+                it('sorts range queries negative integers with or without a cursor', async () => {
                     const testNumbers = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5];
                     for (const digit of testNumbers) {
-                        yield testIndex.put(tenant, digit.toString(), { digit });
+                        await testIndex.put(tenant, digit.toString(), { digit });
                     }
                     const upperBound = 3;
                     const lowerBound = -2;
@@ -853,14 +843,14 @@ describe('IndexLevel', () => {
                                 lte: upperBound
                             }
                         }];
-                    let results = yield testIndex.query(tenant, filters, { sortProperty: 'digit', limit: 4 });
+                    let results = await testIndex.query(tenant, filters, { sortProperty: 'digit', limit: 4 });
                     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)).toBe('number'); // the cursor value is a number, as it was indexed
-                    results = yield testIndex.query(tenant, filters, { sortProperty: 'digit', cursor });
+                    expect(typeof cursor?.value).toBe('number'); // the cursor value is a number, as it was indexed
+                    results = await testIndex.query(tenant, filters, { sortProperty: 'digit', cursor });
                     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* () {
+                });
+                it('sorts range queries with remaining results in lte after cursor', async () => {
                     // create an array with unique IDs but multiple items representing the same digit.
                     const testItems = [{
                             id: 'a',
@@ -888,13 +878,13 @@ describe('IndexLevel', () => {
                             digit: 5,
                         }];
                     for (const item of testItems) {
-                        yield testIndex.put(tenant, item.id, item);
+                        await testIndex.put(tenant, item.id, item);
                     }
                     const lowerBound = 2;
                     const upperBound = 4;
                     // with both lower and upper bounds
                     // first issue with a limit
-                    let response = yield testIndex.query(tenant, [{
+                    let response = await testIndex.query(tenant, [{
                             digit: {
                                 gte: lowerBound,
                                 lte: upperBound
@@ -902,7 +892,7 @@ describe('IndexLevel', () => {
                         }], { sortProperty: 'id', limit: 3 });
                     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, [{
+                    response = await testIndex.query(tenant, [{
                             digit: {
                                 gte: lowerBound,
                                 lte: upperBound
@@ -910,7 +900,7 @@ describe('IndexLevel', () => {
                         }], { sortProperty: 'id', cursor: IndexLevel.createCursorFromLastArrayItem(response, 'id') });
                     expect(response.map(({ messageCid }) => messageCid)).toEqual(['e', 'f', 'g']);
                     // issue a range with no lower bounds but a limit
-                    response = yield testIndex.query(tenant, [{
+                    response = await testIndex.query(tenant, [{
                             digit: {
                                 lte: upperBound
                             },
@@ -919,33 +909,33 @@ describe('IndexLevel', () => {
                     // with no lower bounds
                     // ascending with a cursor
                     // this cursor should ony return results from the 'lte' part of the filter
-                    response = yield testIndex.query(tenant, [{
+                    response = await testIndex.query(tenant, [{
                             digit: {
                                 lte: upperBound
                             },
                         }], { sortProperty: 'id', cursor: IndexLevel.createCursorFromLastArrayItem(response, 'id') });
                     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* () {
+                });
+                it('sorts OR queries with or without a cursor', async () => {
                     const testValsSchema1 = ['a1', 'b1', 'c1', 'd1'];
                     for (const val of testValsSchema1) {
-                        yield testIndex.put(tenant, val, { val, schema: 'schema1' });
+                        await testIndex.put(tenant, val, { val, schema: 'schema1' });
                     }
                     const testValsSchema2 = ['a2', 'b2', 'c2', 'd2'];
                     for (const val of testValsSchema2) {
-                        yield testIndex.put(tenant, val, { val, schema: 'schema2' });
+                        await testIndex.put(tenant, val, { val, schema: 'schema2' });
                     }
                     const filters = [{
                             schema: ['schema1', 'schema2']
                         }];
                     // sort ascending without cursor
-                    let results = yield testIndex.query(tenant, filters, { sortProperty: 'val', limit: 4 });
+                    let results = await testIndex.query(tenant, filters, { sortProperty: 'val', limit: 4 });
                     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') });
+                    results = await testIndex.query(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(results, 'val') });
                     expect(results.map(({ messageCid }) => messageCid)).toEqual(['c1', 'c2', 'd1', 'd2']);
-                }));
-                it('supports multiple filtered queries', () => __awaiter(void 0, void 0, void 0, function* () {
+                });
+                it('supports multiple filtered queries', async () => {
                     const items = [];
                     const lowerBounds = -2;
                     const upperBounds = 3;
@@ -961,7 +951,7 @@ describe('IndexLevel', () => {
                                 TestDataGenerator.randomInt(1, 9);
                         const property = i % 5 === 0 ? true : false;
                         const item = { val: IndexLevel.encodeNumberValue(i), digit, property };
-                        yield testIndex.put(tenant, item.val, item);
+                        await testIndex.put(tenant, item.val, item);
                         items.push(item);
                     }
                     // create the expected results;
@@ -974,36 +964,36 @@ describe('IndexLevel', () => {
                         { property: true }
                     ];
                     // query in ascending order.
-                    const results = yield testIndex.query(tenant, filters, { sortProperty: 'val', limit: 10 });
+                    const results = await testIndex.query(tenant, filters, { sortProperty: 'val', limit: 10 });
                     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') });
+                    const resultsWithCursor = await testIndex.query(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(results, 'val') });
                     expect(resultsWithCursor.map(({ messageCid }) => messageCid)).toEqual([...compareResults].slice(10));
-                    const descResults = yield testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending, limit: 10 });
+                    const descResults = await testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending, limit: 10 });
                     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') });
+                    const descResultsAfterCursor = await testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending, cursor: IndexLevel.createCursorFromLastArrayItem(descResults, 'val') });
                     expect(descResultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual([...compareResults].reverse().slice(10));
-                }));
+                });
             });
         });
     });
     describe('delete', () => {
-        beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+        beforeAll(async () => {
             testIndex = new IndexLevel({
                 createLevelDatabase,
                 location: 'TEST-INDEX',
             });
-            yield testIndex.open();
-        }));
-        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield testIndex.clear();
-        }));
-        afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield testIndex.close();
-        }));
-        it('purges indexes', () => __awaiter(void 0, void 0, void 0, function* () {
+            await testIndex.open();
+        });
+        beforeEach(async () => {
+            await testIndex.clear();
+        });
+        afterAll(async () => {
+            await testIndex.close();
+        });
+        it('purges indexes', async () => {
             const id1 = uuid();
             const doc1 = {
                 id: id1,
@@ -1016,19 +1006,19 @@ describe('IndexLevel', () => {
                 'a': 'b',
                 'c': ['d', 'e']
             };
-            yield testIndex.put(tenant, id1, doc1);
-            yield testIndex.put(tenant, id2, doc2);
-            let result = yield testIndex.query(tenant, [{ 'a': 'b', 'c': 'e' }], { sortProperty: 'id' });
+            await testIndex.put(tenant, id1, doc1);
+            await testIndex.put(tenant, id2, doc2);
+            let result = await testIndex.query(tenant, [{ 'a': 'b', 'c': 'e' }], { sortProperty: 'id' });
             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' });
+            await testIndex.delete(tenant, id1);
+            result = await testIndex.query(tenant, [{ 'a': 'b', 'c': 'e' }], { sortProperty: 'id' });
             expect(result.length).toBe(1);
-            yield testIndex.delete(tenant, id2);
-            const allKeys = yield ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
+            await testIndex.delete(tenant, id2);
+            const allKeys = await ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
             expect(allKeys.length).toBe(0);
-        }));
-        it('should not delete anything if aborted beforehand', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('should not delete anything if aborted beforehand', async () => {
             const controller = new AbortController();
             controller.abort('reason');
             const id = uuid();
@@ -1036,18 +1026,18 @@ describe('IndexLevel', () => {
                 id: id,
                 foo: 'bar'
             };
-            yield testIndex.put(tenant, id, doc);
+            await testIndex.put(tenant, id, doc);
             try {
-                yield testIndex.delete(tenant, id, { signal: controller.signal });
+                await testIndex.delete(tenant, id, { signal: controller.signal });
             }
             catch (e) {
                 expect(e).toBe('reason');
             }
-            const result = yield testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
+            const result = await testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: '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* () {
+        });
+        it('does nothing when attempting to purge key that does not exist', async () => {
             const controller = new AbortController();
             controller.abort('reason');
             const id = uuid();
@@ -1055,16 +1045,16 @@ describe('IndexLevel', () => {
                 id: id,
                 foo: 'bar'
             };
-            yield testIndex.put(tenant, id, doc);
+            await testIndex.put(tenant, id, doc);
             // attempt purge an invalid id
-            yield testIndex.delete(tenant, 'invalidCid');
-            const result = yield testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
+            await testIndex.delete(tenant, 'invalidCid');
+            const result = await testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
             expect(result.length).toBe(1);
             expect(result.map(({ messageCid }) => messageCid)).toContain(id);
-        }));
+        });
     });
     describe('createCursorFromItem', () => {
-        it('throws if cursor value is a boolean or an array', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('throws if cursor value is a boolean or an array', async () => {
             // we can only sort by strings or numbers, so arrays or booleans should throw.
             const item = {
                 messageCid: 'message-cid',
@@ -1075,8 +1065,8 @@ describe('IndexLevel', () => {
             };
             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* () {
+        });
+        it('throws if sort property is not defined within the IndexedItem', async () => {
             const item = {
                 messageCid: 'message-cid',
                 indexes: {
@@ -1084,8 +1074,8 @@ describe('IndexLevel', () => {
                 }
             };
             expect(() => IndexLevel.createCursorFromItem(item, 'unknownProperty')).toThrow(DwnErrorCode.IndexInvalidCursorSortProperty);
-        }));
-        it('returns numeric type cursor value', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('returns numeric type cursor value', async () => {
             const item = {
                 messageCid: 'message-cid',
                 indexes: {
@@ -1094,8 +1084,8 @@ describe('IndexLevel', () => {
             };
             const cursor = IndexLevel.createCursorFromItem(item, 'sortProperty');
             expect(cursor.value).toBe(1234);
-        }));
-        it('returns string type cursor value', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('returns string type cursor value', async () => {
             const item = {
                 messageCid: 'message-cid',
                 indexes: {
@@ -1104,14 +1094,14 @@ describe('IndexLevel', () => {
             };
             const cursor = IndexLevel.createCursorFromItem(item, 'sortProperty');
             expect(cursor.value).toBe('1234');
-        }));
+        });
     });
     describe('createCursorFromLastArrayItem', () => {
-        it('returns undefined if an empty array is provided', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('returns undefined if an empty array is provided', async () => {
             const cursor = IndexLevel.createCursorFromLastArrayItem([], 'someProperty');
             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* () {
+        });
+        it('returns a PaginationCursor for the last item given a valid sort property', async () => {
             const items = [{
                     messageCid: 'cid-1',
                     indexes: {
@@ -1128,17 +1118,17 @@ describe('IndexLevel', () => {
                     }
                 }];
             const cursor = IndexLevel.createCursorFromLastArrayItem(items, 'date');
-            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');
-        }));
+            expect(cursor?.messageCid).toBe('cid-2'); // expect the cursor to equal the messageCid
+            expect(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* () {
+        it('should wrap string in quotes', async () => {
             expect(IndexLevel.encodeValue('test')).toBe(`"test"`);
-        }));
-        it('should return string encoded number using encodeNumberValue()', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('should return string encoded number using encodeNumberValue()', async () => {
             expect(IndexLevel.encodeValue(10)).toBe(IndexLevel.encodeNumberValue(10));
-        }));
+        });
         it('should return stringified boolean', () => {
             expect(IndexLevel.encodeValue(true)).toBe('true');
             expect(IndexLevel.encodeValue(false)).toBe('false');
@@ -1170,17 +1160,17 @@ describe('IndexLevel', () => {
     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* () {
+        it('recordId is always concise', async () => {
             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* () {
+        });
+        it('other than if `recordId` exists, if a cursor exists it is never concise', async () => {
             expect(IndexLevel.isFilterConcise({ schema: 'schema', contextId: 'contextId', parentId: 'parentId' }, queryOptionsWithCursor)).toBe(false);
             // control
             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* () {
+        });
+        it('if there is no cursor -  protocolPath, contextId, parentId, or schema return a concise filter', async () => {
             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);
@@ -1189,17 +1179,17 @@ describe('IndexLevel', () => {
             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* () {
+        });
+        it('if there is no cursor, and it is not one of the conditions, return not concise', async () => {
             expect(IndexLevel.isFilterConcise({ dataSize: { gt: 123 } }, queryOptionsWithoutCursor)).toBe(false);
             // control
             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* () {
+        });
+        it('if protocol filter exists by itself it is not a concise filter', async () => {
             expect(IndexLevel.isFilterConcise({ protocol: 'protocol' }, queryOptionsWithoutCursor)).toBe(false);
             // control
             expect(IndexLevel.isFilterConcise({ protocol: 'protocol', protocolPath: 'path/to' }, queryOptionsWithoutCursor)).toBe(true);
-        }));
+        });
     });
     describe('compound indexes', () => {
         const compoundIndexes = [
@@ -1216,24 +1206,24 @@ describe('IndexLevel', () => {
         ];
         let compoundIndex;
         const compoundTenant = 'did:alice:compound-test';
-        beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+        beforeAll(async () => {
             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();
-        }));
+            await compoundIndex.open();
+        });
+        beforeEach(async () => {
+            await compoundIndex.clear();
+        });
+        afterAll(async () => {
+            await compoundIndex.close();
+        });
         describe('put and delete lifecycle', () => {
-            it('should create compound index entries during put', () => __awaiter(void 0, void 0, void 0, function* () {
+            it('should create compound index entries during put', async () => {
                 const id = uuid();
-                yield compoundIndex.put(compoundTenant, id, {
+                await compoundIndex.put(compoundTenant, id, {
                     protocol: 'https://protocol.xyz',
                     protocolPath: 'chat/message',
                     messageTimestamp: '2024-01-15T10:00:00.000000Z',
@@ -1241,13 +1231,13 @@ describe('IndexLevel', () => {
                     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' });
+                const results = await 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* () {
+            });
+            it('should delete compound index entries during delete', async () => {
                 const id = uuid();
-                yield compoundIndex.put(compoundTenant, id, {
+                await compoundIndex.put(compoundTenant, id, {
                     protocol: 'https://protocol.xyz',
                     protocolPath: 'chat/message',
                     messageTimestamp: '2024-01-15T10:00:00.000000Z',
@@ -1255,30 +1245,30 @@ describe('IndexLevel', () => {
                     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' });
+                let results = await compoundIndex.query(compoundTenant, [{ protocol: 'https://protocol.xyz', protocolPath: 'chat/message' }], { sortProperty: 'messageTimestamp' });
                 expect(results.length).toBe(1);
                 // delete
-                yield compoundIndex.delete(compoundTenant, id);
+                await compoundIndex.delete(compoundTenant, id);
                 // verify compound index entries are removed
-                results = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://protocol.xyz', protocolPath: 'chat/message' }], { sortProperty: 'messageTimestamp' });
+                results = await 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* () {
+            });
+            it('should skip compound index entries when required properties are missing', async () => {
                 const id = uuid();
                 // only has schema, not protocol+protocolPath
-                yield compoundIndex.put(compoundTenant, id, {
+                await 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' });
+                const schemaResults = await 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* () {
+            it('should return results sorted ascending by the sort property', async () => {
                 const ids = ['msg-c', 'msg-a', 'msg-b'];
                 const timestamps = [
                     '2024-01-15T12:00:00.000000Z',
@@ -1286,17 +1276,17 @@ describe('IndexLevel', () => {
                     '2024-01-15T11:00:00.000000Z',
                 ];
                 for (let i = 0; i < ids.length; i++) {
-                    yield compoundIndex.put(compoundTenant, ids[i], {
+                    await 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' });
+                const results = await 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* () {
+            });
+            it('should return results sorted descending by the sort property', async () => {
                 const ids = ['msg-c', 'msg-a', 'msg-b'];
                 const timestamps = [
                     '2024-01-15T12:00:00.000000Z',
@@ -1304,68 +1294,68 @@ describe('IndexLevel', () => {
                     '2024-01-15T11:00:00.000000Z',
                 ];
                 for (let i = 0; i < ids.length; i++) {
-                    yield compoundIndex.put(compoundTenant, ids[i], {
+                    await 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 });
+                const results = await 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* () {
+            });
+            it('should support limit', async () => {
                 for (let i = 0; i < 5; i++) {
-                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                    await 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 });
+                const results = await 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* () {
+            });
+            it('should support cursor pagination ascending', async () => {
                 for (let i = 0; i < 6; i++) {
-                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                    await 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 });
+                const page1 = await 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 });
+                const page2 = await 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* () {
+            });
+            it('should support cursor pagination descending', async () => {
                 for (let i = 0; i < 6; i++) {
-                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                    await 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 });
+                const page1 = await 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 });
+                const page2 = await 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* () {
+            });
+            it('should verify residual filter properties in memory', async () => {
                 // insert records with same protocol+protocolPath but different 'published' values
                 for (let i = 0; i < 4; i++) {
-                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                    await compoundIndex.put(compoundTenant, `msg-${i}`, {
                         protocol: 'https://proto.xyz',
                         protocolPath: 'items',
                         messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
@@ -1374,56 +1364,56 @@ describe('IndexLevel', () => {
                 }
                 // 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' });
+                const results = await 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* () {
+            });
+            it('should only return results matching the specific filter values', async () => {
                 // insert records with different protocol paths
-                yield compoundIndex.put(compoundTenant, 'msg-1', {
+                await 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', {
+                await 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', {
+                await 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' });
+                const results = await 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', {
+            });
+            it('should fall back to non-compound strategy for OR (multi-filter) queries', async () => {
+                await 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', {
+                await 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, [
+                const results = await 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* () {
+            });
+            it('should prefer the compound index with the most properties', async () => {
                 // 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', {
+                await compoundIndex.put(compoundTenant, 'msg-1', {
                     protocol: 'https://proto.xyz',
                     protocolPath: 'items',
                     messageTimestamp: '2024-01-15T10:00:00.000000Z',
@@ -1431,16 +1421,16 @@ describe('IndexLevel', () => {
                     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' });
+                const schemaResults = await 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' });
+                const protocolResults = await 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', {
+            });
+            it('should not use compound index when sort property does not match', async () => {
+                await compoundIndex.put(compoundTenant, 'msg-1', {
                     protocol: 'https://proto.xyz',
                     protocolPath: 'items',
                     messageTimestamp: '2024-01-15T10:00:00.000000Z',
@@ -1450,14 +1440,14 @@ describe('IndexLevel', () => {
                 // 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' });
+                const results = await 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* () {
+            it('should count items matching a compound index filter', async () => {
                 for (let i = 0; i < 10; i++) {
-                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                    await compoundIndex.put(compoundTenant, `msg-${i}`, {
                         protocol: 'https://proto.xyz',
                         protocolPath: 'items',
                         messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
@@ -1465,39 +1455,39 @@ describe('IndexLevel', () => {
                 }
                 // add some non-matching records
                 for (let i = 0; i < 5; i++) {
-                    yield compoundIndex.put(compoundTenant, `other-${i}`, {
+                    await 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' });
+                const count = await 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* () {
+            });
+            it('should count items with residual filter verification', async () => {
                 for (let i = 0; i < 6; i++) {
-                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                    await 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' });
+                const count = await 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', {
+            });
+            it('should return 0 when no items match', async () => {
+                await 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' });
+                const count = await 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* () {
+            });
+            it('should fall back to full query for non-compound-index filters', async () => {
                 for (let i = 0; i < 4; i++) {
-                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                    await compoundIndex.put(compoundTenant, `msg-${i}`, {
                         protocol: 'https://proto.xyz',
                         protocolPath: 'items',
                         messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
@@ -1505,53 +1495,53 @@ describe('IndexLevel', () => {
                     });
                 }
                 // filter by 'published' alone — no compound index covers this
-                const count = yield compoundIndex.count(compoundTenant, [{ published: true }], { sortProperty: 'messageTimestamp' });
+                const count = await 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', {
+            });
+            it('should count correctly with OR (multi-filter) queries', async () => {
+                await 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', {
+                await 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', {
+                await 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, [
+                const count = await 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* () {
+            it('should use compound index for matching single-filter queries with cursor', async () => {
                 // 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}`, {
+                    await 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 });
+                const page1 = await 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 });
+                const page2 = await 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']);
-            }));
+            });
         });
     });
 });