@enbox/dwn-sdk-js 0.0.5 → 0.0.7

package/dist/esm/src/store/index-level.js

@@ -1,72 +1,41 @@
-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());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
 import { isEmptyObject } from '../utils/object.js';
 import { lexicographicalCompare } from '../utils/string.js';
 import { SortDirection } from '../types/query-types.js';
+import { countWithCompoundIndex, createCompoundIndexDeleteOperation, createCompoundIndexPutOperation, queryWithCompoundIndex, selectCompoundIndex, } from './index-level-compound.js';
 import { createLevelDatabase, LevelWrapper } from './level-wrapper.js';
 import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
 import { FilterSelector, FilterUtility } from '../utils/filter.js';
 const INDEX_SUBLEVEL_NAME = 'index';
-/** Separator between compound key segments (higher than \x00 so prefix scans work correctly). */
-const COMPOUND_SEGMENT_SEPARATOR = '\x01';
 /**
  * A LevelDB implementation for indexing the messages and events stored in the DWN.
  */
 export class IndexLevel {
+    db;
+    config;
+    _compoundIndexes;
     constructor(config) {
-        var _a;
-        this.config = Object.assign({ createLevelDatabase }, config);
-        this._compoundIndexes = (_a = config.compoundIndexes) !== null && _a !== void 0 ? _a : [];
+        this.config = {
+            createLevelDatabase,
+            ...config,
+        };
+        this._compoundIndexes = config.compoundIndexes ?? [];
         this.db = new LevelWrapper({
             location: this.config.location,
             createLevelDatabase: this.config.createLevelDatabase,
             keyEncoding: 'utf8'
         });
     }
-    open() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.db.open();
-        });
+    async open() {
+        await this.db.open();
     }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.db.close();
-        });
+    async close() {
+        await this.db.close();
     }
     /**
      * deletes everything in the underlying index db.
      */
-    clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.db.clear();
-        });
+    async clear() {
+        await this.db.clear();
     }
     /**
      * Put an item into the index using information that will allow it to be queried for.
@@ -76,132 +45,120 @@ export class IndexLevel {
      * @param indexes - (key-value pairs) to be included as part of indexing this item. Must include at least one indexing property.
      * @param options IndexLevelOptions that include an AbortSignal.
      */
-    put(tenant, messageCid, indexes, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // ensure we have something valid to index
-            if (isEmptyObject(indexes)) {
-                throw new DwnError(DwnErrorCode.IndexMissingIndexableProperty, 'Index must include at least one valid indexable property');
-            }
-            const item = { messageCid, indexes };
-            const opCreationPromises = [];
-            // create an index entry for each property index
-            // these indexes are all sortable lexicographically.
-            for (const indexName in indexes) {
-                const indexValue = indexes[indexName];
-                if (Array.isArray(indexValue)) {
-                    for (const indexValueItem of indexValue) {
-                        const partitionOperationPromise = this.createPutIndexedItemOperation(tenant, item, indexName, indexValueItem);
-                        opCreationPromises.push(partitionOperationPromise);
-                    }
-                }
-                else {
-                    const partitionOperationPromise = this.createPutIndexedItemOperation(tenant, item, indexName, indexValue);
+    async put(tenant, messageCid, indexes, options) {
+        // ensure we have something valid to index
+        if (isEmptyObject(indexes)) {
+            throw new DwnError(DwnErrorCode.IndexMissingIndexableProperty, 'Index must include at least one valid indexable property');
+        }
+        const item = { messageCid, indexes };
+        const opCreationPromises = [];
+        // create an index entry for each property index
+        // these indexes are all sortable lexicographically.
+        for (const indexName in indexes) {
+            const indexValue = indexes[indexName];
+            if (Array.isArray(indexValue)) {
+                for (const indexValueItem of indexValue) {
+                    const partitionOperationPromise = this.createPutIndexedItemOperation(tenant, item, indexName, indexValueItem);
                     opCreationPromises.push(partitionOperationPromise);
                 }
             }
-            // create compound index entries for any registered compound indexes whose properties are all present in the indexes.
-            for (const compoundIndex of this._compoundIndexes) {
-                const compoundOp = this.createCompoundIndexPutOperation(tenant, item, compoundIndex);
-                if (compoundOp !== undefined) {
-                    opCreationPromises.push(compoundOp);
-                }
+            else {
+                const partitionOperationPromise = this.createPutIndexedItemOperation(tenant, item, indexName, indexValue);
+                opCreationPromises.push(partitionOperationPromise);
             }
-            // create a reverse lookup for the sortedIndex values. This is used during deletion and cursor starting point lookup.
-            const partitionOperationPromise = this.createOperationForIndexesLookupPartition(tenant, { type: 'put', key: messageCid, value: JSON.stringify(indexes) });
-            opCreationPromises.push(partitionOperationPromise);
-            const indexOps = yield Promise.all(opCreationPromises);
-            const tenantPartition = yield this.db.partition(tenant);
-            yield tenantPartition.batch(indexOps, options);
-        });
+        }
+        // create compound index entries for any registered compound indexes whose properties are all present in the indexes.
+        for (const compoundIndex of this._compoundIndexes) {
+            const compoundOp = createCompoundIndexPutOperation(this.db, tenant, item, compoundIndex, IndexLevel.encodeValue, IndexLevel.delimiter);
+            if (compoundOp !== undefined) {
+                opCreationPromises.push(compoundOp);
+            }
+        }
+        // create a reverse lookup for the sortedIndex values. This is used during deletion and cursor starting point lookup.
+        const partitionOperationPromise = this.createOperationForIndexesLookupPartition(tenant, { type: 'put', key: messageCid, value: JSON.stringify(indexes) });
+        opCreationPromises.push(partitionOperationPromise);
+        const indexOps = await Promise.all(opCreationPromises);
+        const tenantPartition = await this.db.partition(tenant);
+        await tenantPartition.batch(indexOps, options);
     }
     /**
      *  Deletes all of the index data associated with the item.
      */
-    delete(tenant, messageCid, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const opCreationPromises = [];
-            const indexes = yield this.getIndexes(tenant, messageCid);
-            if (indexes === undefined) {
-                // invalid messageCid
-                return;
-            }
-            // delete the reverse lookup
-            const partitionOperationPromise = this.createOperationForIndexesLookupPartition(tenant, { type: 'del', key: messageCid });
-            opCreationPromises.push(partitionOperationPromise);
-            // delete the keys for each index
-            for (const indexName in indexes) {
-                const indexValue = indexes[indexName];
-                if (Array.isArray(indexValue)) {
-                    for (const indexValueItem of indexValue) {
-                        const partitionOperationPromise = this.createDeleteIndexedItemOperation(tenant, messageCid, indexName, indexValueItem);
-                        opCreationPromises.push(partitionOperationPromise);
-                    }
-                }
-                else {
-                    const partitionOperationPromise = this.createDeleteIndexedItemOperation(tenant, messageCid, indexName, indexValue);
+    async delete(tenant, messageCid, options) {
+        const opCreationPromises = [];
+        const indexes = await this.getIndexes(tenant, messageCid);
+        if (indexes === undefined) {
+            // invalid messageCid
+            return;
+        }
+        // delete the reverse lookup
+        const partitionOperationPromise = this.createOperationForIndexesLookupPartition(tenant, { type: 'del', key: messageCid });
+        opCreationPromises.push(partitionOperationPromise);
+        // delete the keys for each index
+        for (const indexName in indexes) {
+            const indexValue = indexes[indexName];
+            if (Array.isArray(indexValue)) {
+                for (const indexValueItem of indexValue) {
+                    const partitionOperationPromise = this.createDeleteIndexedItemOperation(tenant, messageCid, indexName, indexValueItem);
                     opCreationPromises.push(partitionOperationPromise);
                 }
             }
-            // delete compound index entries
-            for (const compoundIndex of this._compoundIndexes) {
-                const compoundOp = this.createCompoundIndexDeleteOperation(tenant, messageCid, indexes, compoundIndex);
-                if (compoundOp !== undefined) {
-                    opCreationPromises.push(compoundOp);
-                }
+            else {
+                const partitionOperationPromise = this.createDeleteIndexedItemOperation(tenant, messageCid, indexName, indexValue);
+                opCreationPromises.push(partitionOperationPromise);
             }
-            const indexOps = yield Promise.all(opCreationPromises);
-            const tenantPartition = yield this.db.partition(tenant);
-            yield tenantPartition.batch(indexOps, options);
-        });
+        }
+        // delete compound index entries
+        for (const compoundIndex of this._compoundIndexes) {
+            const compoundOp = createCompoundIndexDeleteOperation(this.db, tenant, messageCid, indexes, compoundIndex, IndexLevel.encodeValue, IndexLevel.delimiter);
+            if (compoundOp !== undefined) {
+                opCreationPromises.push(compoundOp);
+            }
+        }
+        const indexOps = await Promise.all(opCreationPromises);
+        const tenantPartition = await this.db.partition(tenant);
+        await tenantPartition.batch(indexOps, options);
     }
     /**
      * Creates an IndexLevel `put` operation for indexing an item, creating a partition by `tenant` and by `indexName`
      */
-    createPutIndexedItemOperation(tenant, item, indexName, indexValue) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { messageCid } = item;
-            // The key is the indexValue followed by the messageCid as a tie-breaker.
-            // for example if the property is messageTimestamp the key would look like:
-            // '"2023-05-25T18:23:29.425008Z"\u0000bafyreigs3em7lrclhntzhgvkrf75j2muk6e7ypq3lrw3ffgcpyazyw6pry'
-            const key = IndexLevel.keySegmentJoin(IndexLevel.encodeValue(indexValue), messageCid);
-            return this.createOperationForIndexPartition(tenant, indexName, { type: 'put', key, value: JSON.stringify(item) });
-        });
+    async createPutIndexedItemOperation(tenant, item, indexName, indexValue) {
+        const { messageCid } = item;
+        // The key is the indexValue followed by the messageCid as a tie-breaker.
+        // for example if the property is messageTimestamp the key would look like:
+        // '"2023-05-25T18:23:29.425008Z"\u0000bafyreigs3em7lrclhntzhgvkrf75j2muk6e7ypq3lrw3ffgcpyazyw6pry'
+        const key = IndexLevel.keySegmentJoin(IndexLevel.encodeValue(indexValue), messageCid);
+        return this.createOperationForIndexPartition(tenant, indexName, { type: 'put', key, value: JSON.stringify(item) });
     }
     /**
      * Creates an IndexLevel `del` operation for deleting an item, creating a partition by `tenant` and by `indexName`
      */
-    createDeleteIndexedItemOperation(tenant, messageCid, indexName, indexValue) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // The key is the indexValue followed by the messageCid as a tie-breaker.
-            // for example if the property is messageTimestamp the key would look like:
-            // '"2023-05-25T18:23:29.425008Z"\u0000bafyreigs3em7lrclhntzhgvkrf75j2muk6e7ypq3lrw3ffgcpyazyw6pry'
-            const key = IndexLevel.keySegmentJoin(IndexLevel.encodeValue(indexValue), messageCid);
-            return this.createOperationForIndexPartition(tenant, indexName, { type: 'del', key });
-        });
+    async createDeleteIndexedItemOperation(tenant, messageCid, indexName, indexValue) {
+        // The key is the indexValue followed by the messageCid as a tie-breaker.
+        // for example if the property is messageTimestamp the key would look like:
+        // '"2023-05-25T18:23:29.425008Z"\u0000bafyreigs3em7lrclhntzhgvkrf75j2muk6e7ypq3lrw3ffgcpyazyw6pry'
+        const key = IndexLevel.keySegmentJoin(IndexLevel.encodeValue(indexValue), messageCid);
+        return this.createOperationForIndexPartition(tenant, indexName, { type: 'del', key });
     }
     /**
      * Wraps the given operation as an operation for the specified index partition.
      */
-    createOperationForIndexPartition(tenant, indexName, operation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // we write the index entry into a sublevel-partition of tenantPartition.
-            // putting each index entry within a sublevel allows the levelDB system to calculate a gt minKey and lt maxKey for each of the properties
-            // this prevents them from clashing, especially when iterating in reverse without iterating through other properties.
-            const tenantPartition = yield this.db.partition(tenant);
-            const indexPartitionName = IndexLevel.getIndexPartitionName(indexName);
-            const partitionOperation = tenantPartition.createPartitionOperation(indexPartitionName, operation);
-            return partitionOperation;
-        });
+    async createOperationForIndexPartition(tenant, indexName, operation) {
+        // we write the index entry into a sublevel-partition of tenantPartition.
+        // putting each index entry within a sublevel allows the levelDB system to calculate a gt minKey and lt maxKey for each of the properties
+        // this prevents them from clashing, especially when iterating in reverse without iterating through other properties.
+        const tenantPartition = await this.db.partition(tenant);
+        const indexPartitionName = IndexLevel.getIndexPartitionName(indexName);
+        const partitionOperation = tenantPartition.createPartitionOperation(indexPartitionName, operation);
+        return partitionOperation;
     }
     /**
      * Wraps the given operation as an operation for the messageCid to indexes lookup partition.
      */
-    createOperationForIndexesLookupPartition(tenant, operation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tenantPartition = yield this.db.partition(tenant);
-            const partitionOperation = tenantPartition.createPartitionOperation(INDEX_SUBLEVEL_NAME, operation);
-            return partitionOperation;
-        });
+    async createOperationForIndexesLookupPartition(tenant, operation) {
+        const tenantPartition = await this.db.partition(tenant);
+        const partitionOperation = tenantPartition.createPartitionOperation(INDEX_SUBLEVEL_NAME, operation);
+        return partitionOperation;
     }
     static getIndexPartitionName(indexName) {
         // we create index partition names in __${indexName}__ wrapping so they do not clash with other sublevels that are created for other purposes.
@@ -210,19 +167,15 @@ export class IndexLevel {
     /**
      * Gets the index partition of the given indexName.
      */
-    getIndexPartition(tenant, indexName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const indexPartitionName = IndexLevel.getIndexPartitionName(indexName);
-            return (yield this.db.partition(tenant)).partition(indexPartitionName);
-        });
+    async getIndexPartition(tenant, indexName) {
+        const indexPartitionName = IndexLevel.getIndexPartitionName(indexName);
+        return (await this.db.partition(tenant)).partition(indexPartitionName);
     }
     /**
      * Gets the messageCid to indexes lookup partition.
      */
-    getIndexesLookupPartition(tenant) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.db.partition(tenant)).partition(INDEX_SUBLEVEL_NAME);
-        });
+    async getIndexesLookupPartition(tenant) {
+        return (await this.db.partition(tenant)).partition(INDEX_SUBLEVEL_NAME);
     }
     /**
      * Queries the index for items that match the filters. If no filters are provided, all items are returned.
@@ -238,22 +191,20 @@ export class IndexLevel {
      * @param options IndexLevelOptions that include an AbortSignal.
      * @returns {IndexedItem[]} an array of `IndexedItem` that match the given filters.
      */
-    query(tenant, filters, queryOptions, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Strategy 1: try compound index for single-filter queries
-            if (filters.length === 1 && !isEmptyObject(filters[0])) {
-                const compoundResult = this.selectCompoundIndex(filters[0], queryOptions);
-                if (compoundResult !== undefined) {
-                    return this.queryWithCompoundIndex(tenant, filters[0], queryOptions, compoundResult, options);
-                }
-            }
-            // Strategy 2: in-memory paging for concise filters
-            if (IndexLevel.shouldQueryWithInMemoryPaging(filters, queryOptions)) {
-                return this.queryWithInMemoryPaging(tenant, filters, queryOptions, options);
+    async query(tenant, filters, queryOptions, options) {
+        // Strategy 1: try compound index for single-filter queries
+        if (filters.length === 1 && !isEmptyObject(filters[0])) {
+            const compoundResult = selectCompoundIndex(filters[0], queryOptions, this._compoundIndexes);
+            if (compoundResult !== undefined) {
+                return queryWithCompoundIndex(this.db, tenant, filters[0], queryOptions, compoundResult, IndexLevel.encodeValue, IndexLevel.delimiter, this.queryWithIteratorPaging.bind(this), options);
             }
-            // Strategy 3: iterator paging (default)
-            return this.queryWithIteratorPaging(tenant, filters, queryOptions, options);
-        });
+        }
+        // Strategy 2: in-memory paging for concise filters
+        if (IndexLevel.shouldQueryWithInMemoryPaging(filters, queryOptions)) {
+            return this.queryWithInMemoryPaging(tenant, filters, queryOptions, options);
+        }
+        // Strategy 3: iterator paging (default)
+        return this.queryWithIteratorPaging(tenant, filters, queryOptions, options);
     }
     /**
      * Counts the number of items that match the given filters without loading full records.
@@ -261,94 +212,62 @@ export class IndexLevel {
      * When a compound index covers the query, counting is a simple key iteration without value deserialization.
      * Otherwise, falls back to counting via the existing query strategies.
      */
-    count(tenant, filters, queryOptions, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // try compound index for single-filter queries
-            if (filters.length === 1 && !isEmptyObject(filters[0])) {
-                const compoundResult = this.selectCompoundIndex(filters[0], Object.assign({}, queryOptions));
-                if (compoundResult !== undefined) {
-                    return this.countWithCompoundIndex(tenant, filters[0], compoundResult, options);
-                }
+    async count(tenant, filters, queryOptions, options) {
+        // try compound index for single-filter queries
+        if (filters.length === 1 && !isEmptyObject(filters[0])) {
+            const compoundResult = selectCompoundIndex(filters[0], { ...queryOptions }, this._compoundIndexes);
+            if (compoundResult !== undefined) {
+                return countWithCompoundIndex(this.db, tenant, filters[0], compoundResult, IndexLevel.encodeValue, this.query.bind(this), options);
             }
-            // fallback: run a full query without limit and count the results
-            const results = yield this.query(tenant, filters, Object.assign({}, queryOptions), options);
-            return results.length;
-        });
+        }
+        // fallback: run a full query without limit and count the results
+        const results = await this.query(tenant, filters, { ...queryOptions }, options);
+        return results.length;
     }
     /**
      * Queries the sort property index for items that match the filters. If no filters are provided, all items are returned.
      * This query is a linear iterator over the sorted index, checking each item for a match.
      * If a cursor is provided it starts the iteration from the cursor point.
      */
-    queryWithIteratorPaging(tenant, filters, queryOptions, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            const { cursor: queryCursor, limit } = queryOptions;
-            // if there is a cursor we fetch the starting key given the sort property, otherwise we start from the beginning of the index.
-            const startKey = queryCursor ? this.createStartingKeyFromCursor(queryCursor) : '';
-            const matches = [];
-            try {
-                for (var _d = true, _e = __asyncValues(this.getIndexIterator(tenant, startKey, queryOptions, options)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const item = _c;
-                    if (limit !== undefined && limit === matches.length) {
-                        break;
-                    }
-                    const { indexes } = item;
-                    if (FilterUtility.matchAnyFilter(indexes, filters)) {
-                        matches.push(item);
-                    }
-                }
+    async queryWithIteratorPaging(tenant, filters, queryOptions, options) {
+        const { cursor: queryCursor, limit } = queryOptions;
+        // if there is a cursor we fetch the starting key given the sort property, otherwise we start from the beginning of the index.
+        const startKey = queryCursor ? this.createStartingKeyFromCursor(queryCursor) : '';
+        const matches = [];
+        for await (const item of this.getIndexIterator(tenant, startKey, queryOptions, options)) {
+            if (limit !== undefined && limit === matches.length) {
+                break;
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_1) throw e_1.error; }
+            const { indexes } = item;
+            if (FilterUtility.matchAnyFilter(indexes, filters)) {
+                matches.push(item);
             }
-            return matches;
-        });
+        }
+        return matches;
     }
     /**
      * Creates an AsyncGenerator that returns each sorted index item given a specific sortProperty.
      * If a cursor is passed, the starting value (gt or lt) is derived from that.
      */
-    getIndexIterator(tenant, startKey, queryOptions, options) {
-        return __asyncGenerator(this, arguments, function* getIndexIterator_1() {
-            var _a, e_2, _b, _c;
-            const { sortProperty, sortDirection = SortDirection.Ascending, cursor } = queryOptions;
-            const iteratorOptions = {
-                gt: startKey
-            };
-            // if we are sorting in descending order we can iterate in reverse.
-            if (sortDirection === SortDirection.Descending) {
-                iteratorOptions.reverse = true;
-                // if a cursor is provided and we are sorting in descending order, the startKey should be the upper bound.
-                if (cursor !== undefined) {
-                    iteratorOptions.lt = startKey;
-                    delete iteratorOptions.gt;
-                }
-            }
-            const sortPartition = yield __await(this.getIndexPartition(tenant, sortProperty));
-            try {
-                for (var _d = true, _e = __asyncValues(sortPartition.iterator(iteratorOptions, options)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const [_, val] = _c;
-                    const { indexes, messageCid } = JSON.parse(val);
-                    yield yield __await({ indexes, messageCid });
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                }
-                finally { if (e_2) throw e_2.error; }
+    async *getIndexIterator(tenant, startKey, queryOptions, options) {
+        const { sortProperty, sortDirection = SortDirection.Ascending, cursor } = queryOptions;
+        const iteratorOptions = {
+            gt: startKey
+        };
+        // if we are sorting in descending order we can iterate in reverse.
+        if (sortDirection === SortDirection.Descending) {
+            iteratorOptions.reverse = true;
+            // if a cursor is provided and we are sorting in descending order, the startKey should be the upper bound.
+            if (cursor !== undefined) {
+                iteratorOptions.lt = startKey;
+                delete iteratorOptions.gt;
             }
-        });
+        }
+        const sortPartition = await this.getIndexPartition(tenant, sortProperty);
+        for await (const [_, val] of sortPartition.iterator(iteratorOptions, options)) {
+            const { indexes, messageCid } = JSON.parse(val);
+            yield { indexes, messageCid };
+        }
     }
     /**
      * Creates the starting point for a LevelDB query given an messageCid as a cursor and the indexed property.
@@ -394,151 +313,117 @@ export class IndexLevel {
      *
      * @throws {DwnErrorCode.IndexLevelInMemoryInvalidSortProperty} if an invalid sort property is provided.
      */
-    queryWithInMemoryPaging(tenant, filters, queryOptions, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { sortProperty, sortDirection = SortDirection.Ascending, cursor: queryCursor, limit } = queryOptions;
-            // we get the cursor start key here so that we match the failing behavior of `queryWithIteratorPaging`
-            const cursorStartingKey = queryCursor ? this.createStartingKeyFromCursor(queryCursor) : undefined;
-            // we create a matches map so that we can short-circuit matched items within the async single query below.
-            const matches = new Map();
-            // If the filter is empty, we just give it an empty filter so that we can iterate over all the items later in executeSingleFilterQuery().
-            // We could do the iteration here, but it would be duplicating the same logic, so decided to just setup the data structure here.
-            if (filters.length === 0) {
-                filters = [{}];
-            }
-            try {
-                yield Promise.all(filters.map(filter => {
-                    return this.executeSingleFilterQuery(tenant, filter, sortProperty, matches, options);
-                }));
-            }
-            catch (error) {
-                if (error.code === DwnErrorCode.IndexInvalidSortPropertyInMemory) {
-                    // return empty results if the sort property is invalid.
-                    return [];
-                }
-            }
-            const sortedValues = [...matches.values()].sort((a, b) => this.sortItems(a, b, sortProperty, sortDirection));
-            const start = cursorStartingKey !== undefined ? this.findCursorStartingIndex(sortedValues, sortDirection, sortProperty, cursorStartingKey) : 0;
-            if (start < 0) {
-                // if the provided cursor does not come before any of the results, we return no results
+    async queryWithInMemoryPaging(tenant, filters, queryOptions, options) {
+        const { sortProperty, sortDirection = SortDirection.Ascending, cursor: queryCursor, limit } = queryOptions;
+        // we get the cursor start key here so that we match the failing behavior of `queryWithIteratorPaging`
+        const cursorStartingKey = queryCursor ? this.createStartingKeyFromCursor(queryCursor) : undefined;
+        // we create a matches map so that we can short-circuit matched items within the async single query below.
+        const matches = new Map();
+        // If the filter is empty, we just give it an empty filter so that we can iterate over all the items later in executeSingleFilterQuery().
+        // We could do the iteration here, but it would be duplicating the same logic, so decided to just setup the data structure here.
+        if (filters.length === 0) {
+            filters = [{}];
+        }
+        try {
+            await Promise.all(filters.map(filter => {
+                return this.executeSingleFilterQuery(tenant, filter, sortProperty, matches, options);
+            }));
+        }
+        catch (error) {
+            if (error.code === DwnErrorCode.IndexInvalidSortPropertyInMemory) {
+                // return empty results if the sort property is invalid.
                 return [];
             }
-            const end = limit !== undefined ? start + limit : undefined;
-            return sortedValues.slice(start, end);
-        });
+        }
+        const sortedValues = [...matches.values()].sort((a, b) => this.sortItems(a, b, sortProperty, sortDirection));
+        const start = cursorStartingKey !== undefined ? this.findCursorStartingIndex(sortedValues, sortDirection, sortProperty, cursorStartingKey) : 0;
+        if (start < 0) {
+            // if the provided cursor does not come before any of the results, we return no results
+            return [];
+        }
+        const end = limit !== undefined ? start + limit : undefined;
+        return sortedValues.slice(start, end);
     }
     /**
      * Execute a filtered query against a single filter and return all results.
      */
-    executeSingleFilterQuery(tenant, filter, sortProperty, matches, levelOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Note: We have an array of Promises in order to support OR (anyOf) matches when given a list of accepted values for a property
-            const filterPromises = [];
-            // If the filter is empty, then we just iterate over one of the indexes that contains all the records and return all items.
-            if (isEmptyObject(filter)) {
-                const getAllItemsPromise = this.getAllItems(tenant, sortProperty);
-                filterPromises.push(getAllItemsPromise);
-            }
-            // else the filter is not empty
-            const searchFilter = FilterSelector.reduceFilter(filter);
-            for (const propertyName in searchFilter) {
-                const propertyFilter = searchFilter[propertyName];
-                // We will find the union of these many individual queries later.
-                if (FilterUtility.isEqualFilter(propertyFilter)) {
-                    // propertyFilter is an EqualFilter, meaning it is a non-object primitive type
-                    const exactMatchesPromise = this.filterExactMatches(tenant, propertyName, propertyFilter, levelOptions);
+    async executeSingleFilterQuery(tenant, filter, sortProperty, matches, levelOptions) {
+        // Note: We have an array of Promises in order to support OR (anyOf) matches when given a list of accepted values for a property
+        const filterPromises = [];
+        // If the filter is empty, then we just iterate over one of the indexes that contains all the records and return all items.
+        if (isEmptyObject(filter)) {
+            const getAllItemsPromise = this.getAllItems(tenant, sortProperty);
+            filterPromises.push(getAllItemsPromise);
+        }
+        // else the filter is not empty
+        const searchFilter = FilterSelector.reduceFilter(filter);
+        for (const propertyName in searchFilter) {
+            const propertyFilter = searchFilter[propertyName];
+            // We will find the union of these many individual queries later.
+            if (FilterUtility.isEqualFilter(propertyFilter)) {
+                // propertyFilter is an EqualFilter, meaning it is a non-object primitive type
+                const exactMatchesPromise = this.filterExactMatches(tenant, propertyName, propertyFilter, levelOptions);
+                filterPromises.push(exactMatchesPromise);
+            }
+            else if (FilterUtility.isOneOfFilter(propertyFilter)) {
+                // `propertyFilter` is a OneOfFilter
+                // Support OR matches by querying for each values separately, then adding them to the promises array.
+                for (const propertyValue of new Set(propertyFilter)) {
+                    const exactMatchesPromise = this.filterExactMatches(tenant, propertyName, propertyValue, levelOptions);
                     filterPromises.push(exactMatchesPromise);
                 }
-                else if (FilterUtility.isOneOfFilter(propertyFilter)) {
-                    // `propertyFilter` is a OneOfFilter
-                    // Support OR matches by querying for each values separately, then adding them to the promises array.
-                    for (const propertyValue of new Set(propertyFilter)) {
-                        const exactMatchesPromise = this.filterExactMatches(tenant, propertyName, propertyValue, levelOptions);
-                        filterPromises.push(exactMatchesPromise);
-                    }
-                }
-                else if (FilterUtility.isRangeFilter(propertyFilter)) {
-                    // `propertyFilter` is a `RangeFilter`
-                    const rangeMatchesPromise = this.filterRangeMatches(tenant, propertyName, propertyFilter, levelOptions);
-                    filterPromises.push(rangeMatchesPromise);
-                }
             }
-            // acting as an OR match for the property, any of the promises returning a match will be treated as a property match
-            for (const promise of filterPromises) {
-                const indexItems = yield promise;
-                // reminder: the promise returns a list of IndexedItem satisfying a particular property match
-                for (const indexedItem of indexItems) {
-                    // short circuit: if a data is already included to the final matched key set (by a different `Filter`),
-                    // no need to evaluate if the data satisfies this current filter being evaluated
-                    // otherwise check that the item is a match.
-                    if (matches.has(indexedItem.messageCid) || !FilterUtility.matchFilter(indexedItem.indexes, filter)) {
-                        continue;
-                    }
-                    // ensure that each matched item has the sortProperty, otherwise fail the entire query.
-                    if (indexedItem.indexes[sortProperty] === undefined) {
-                        throw new DwnError(DwnErrorCode.IndexInvalidSortPropertyInMemory, `invalid sort property ${sortProperty}`);
-                    }
-                    matches.set(indexedItem.messageCid, indexedItem);
-                }
+            else if (FilterUtility.isRangeFilter(propertyFilter)) {
+                // `propertyFilter` is a `RangeFilter`
+                const rangeMatchesPromise = this.filterRangeMatches(tenant, propertyName, propertyFilter, levelOptions);
+                filterPromises.push(rangeMatchesPromise);
             }
-        });
-    }
-    getAllItems(tenant, sortProperty) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_3, _b, _c;
-            const filterPartition = yield this.getIndexPartition(tenant, sortProperty);
-            const items = [];
-            try {
-                for (var _d = true, _e = __asyncValues(filterPartition.iterator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const [_key, value] = _c;
-                    items.push(JSON.parse(value));
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_3) throw e_3.error; }
+        }
+        // acting as an OR match for the property, any of the promises returning a match will be treated as a property match
+        for (const promise of filterPromises) {
+            const indexItems = await promise;
+            // reminder: the promise returns a list of IndexedItem satisfying a particular property match
+            for (const indexedItem of indexItems) {
+                // short circuit: if a data is already included to the final matched key set (by a different `Filter`),
+                // no need to evaluate if the data satisfies this current filter being evaluated
+                // otherwise check that the item is a match.
+                if (matches.has(indexedItem.messageCid) || !FilterUtility.matchFilter(indexedItem.indexes, filter)) {
+                    continue;
+                }
+                // ensure that each matched item has the sortProperty, otherwise fail the entire query.
+                if (indexedItem.indexes[sortProperty] === undefined) {
+                    throw new DwnError(DwnErrorCode.IndexInvalidSortPropertyInMemory, `invalid sort property ${sortProperty}`);
+                }
+                matches.set(indexedItem.messageCid, indexedItem);
             }
-            return items;
-        });
+        }
+    }
+    async getAllItems(tenant, sortProperty) {
+        const filterPartition = await this.getIndexPartition(tenant, sortProperty);
+        const items = [];
+        for await (const [_key, value] of filterPartition.iterator()) {
+            items.push(JSON.parse(value));
+        }
+        return items;
     }
     /**
      * Returns items that match the exact property and value.
      */
-    filterExactMatches(tenant, propertyName, propertyValue, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_4, _b, _c;
-            const matchPrefix = IndexLevel.keySegmentJoin(IndexLevel.encodeValue(propertyValue));
-            const iteratorOptions = {
-                gt: matchPrefix
-            };
-            const filterPartition = yield this.getIndexPartition(tenant, propertyName);
-            const matches = [];
-            try {
-                for (var _d = true, _e = __asyncValues(filterPartition.iterator(iteratorOptions, options)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const [key, value] = _c;
-                    // immediately stop if we arrive at an index that contains a different property value
-                    if (!key.startsWith(matchPrefix)) {
-                        break;
-                    }
-                    matches.push(JSON.parse(value));
-                }
-            }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_4) throw e_4.error; }
-            }
-            return matches;
-        });
+    async filterExactMatches(tenant, propertyName, propertyValue, options) {
+        const matchPrefix = IndexLevel.keySegmentJoin(IndexLevel.encodeValue(propertyValue));
+        const iteratorOptions = {
+            gt: matchPrefix
+        };
+        const filterPartition = await this.getIndexPartition(tenant, propertyName);
+        const matches = [];
+        for await (const [key, value] of filterPartition.iterator(iteratorOptions, options)) {
+            // immediately stop if we arrive at an index that contains a different property value
+            if (!key.startsWith(matchPrefix)) {
+                break;
+            }
+            matches.push(JSON.parse(value));
+        }
+        return matches;
     }
     /**
      * Returns items that match the range filter.
@@ -547,51 +432,36 @@ export class IndexLevel {
      * of the form `<encodedValue>\x00<messageCid>` are naturally included in the range scan,
      * eliminating the need for a separate exact-match query.
      */
-    filterRangeMatches(tenant, propertyName, rangeFilter, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_5, _b, _c;
-            const iteratorOptions = {};
-            for (const comparator in rangeFilter) {
-                const comparatorName = comparator;
-                const encodedValue = IndexLevel.encodeValue(rangeFilter[comparatorName]);
-                if (comparatorName === 'lte') {
-                    // Extend the lte bound so that composite keys `<encodedValue>\x00<messageCid>` are included.
-                    // Since \x00 < \xff, any key starting with encodedValue followed by the \x00 delimiter
-                    // will be lexicographically less than encodedValue + \xff.
-                    iteratorOptions[comparatorName] = encodedValue + '\xff';
-                }
-                else {
-                    iteratorOptions[comparatorName] = encodedValue;
-                }
+    async filterRangeMatches(tenant, propertyName, rangeFilter, options) {
+        const iteratorOptions = {};
+        for (const comparator in rangeFilter) {
+            const comparatorName = comparator;
+            const encodedValue = IndexLevel.encodeValue(rangeFilter[comparatorName]);
+            if (comparatorName === 'lte') {
+                // Extend the lte bound so that composite keys `<encodedValue>\x00<messageCid>` are included.
+                // Since \x00 < \xff, any key starting with encodedValue followed by the \x00 delimiter
+                // will be lexicographically less than encodedValue + \xff.
+                iteratorOptions[comparatorName] = encodedValue + '\xff';
             }
-            // if there is no lower bound specified (`gt` or `gte`), we need to iterate from the upper bound,
-            // so that we will iterate over all the matches before hitting mismatches.
-            if (iteratorOptions.gt === undefined && iteratorOptions.gte === undefined) {
-                iteratorOptions.reverse = true;
-            }
-            const matches = [];
-            const filterPartition = yield this.getIndexPartition(tenant, propertyName);
-            try {
-                for (var _d = true, _e = __asyncValues(filterPartition.iterator(iteratorOptions, options)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const [key, value] = _c;
-                    // if "greater-than" is specified, skip all keys that contain the exact value given in the "greater-than" condition
-                    if ('gt' in rangeFilter && this.extractIndexValueFromKey(key) === IndexLevel.encodeValue(rangeFilter.gt)) {
-                        continue;
-                    }
-                    matches.push(JSON.parse(value));
-                }
+            else {
+                iteratorOptions[comparatorName] = encodedValue;
             }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_5) throw e_5.error; }
+        }
+        // if there is no lower bound specified (`gt` or `gte`), we need to iterate from the upper bound,
+        // so that we will iterate over all the matches before hitting mismatches.
+        if (iteratorOptions.gt === undefined && iteratorOptions.gte === undefined) {
+            iteratorOptions.reverse = true;
+        }
+        const matches = [];
+        const filterPartition = await this.getIndexPartition(tenant, propertyName);
+        for await (const [key, value] of filterPartition.iterator(iteratorOptions, options)) {
+            // if "greater-than" is specified, skip all keys that contain the exact value given in the "greater-than" condition
+            if ('gt' in rangeFilter && this.extractIndexValueFromKey(key) === IndexLevel.encodeValue(rangeFilter.gt)) {
+                continue;
             }
-            return matches;
-        });
+            matches.push(JSON.parse(value));
+        }
+        return matches;
     }
     /**
      * Sorts Items lexicographically in ascending or descending order given a specific indexName, using the messageCid as a tie breaker.
@@ -639,16 +509,14 @@ export class IndexLevel {
     /**
      * Gets the indexes given an messageCid. This is a reverse lookup to construct starting keys, as well as deleting indexed items.
      */
-    getIndexes(tenant, messageCid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const indexesLookupPartition = yield this.getIndexesLookupPartition(tenant);
-            const serializedIndexes = yield indexesLookupPartition.get(messageCid);
-            if (serializedIndexes === undefined) {
-                // invalid messageCid
-                return;
-            }
-            return JSON.parse(serializedIndexes);
-        });
+    async getIndexes(tenant, messageCid) {
+        const indexesLookupPartition = await this.getIndexesLookupPartition(tenant);
+        const serializedIndexes = await indexesLookupPartition.get(messageCid);
+        if (serializedIndexes === undefined) {
+            // invalid messageCid
+            return;
+        }
+        return JSON.parse(serializedIndexes);
     }
     /**
      * Given a key from an indexed partitioned property key.
@@ -660,6 +528,10 @@ export class IndexLevel {
         const [value] = key.split(IndexLevel.delimiter);
         return value;
     }
+    /**
+     * Joins the given values using the `\x00` (\u0000) character.
+     */
+    static delimiter = `\x00`;
     static keySegmentJoin(...values) {
         return values.join(IndexLevel.delimiter);
     }
@@ -694,292 +566,6 @@ export class IndexLevel {
         }
     }
     // =========================================================================
-    // Compound index methods
-    // =========================================================================
-    /**
-     * Gets the compound index partition for a given compound index definition.
-     * Compound index sublevels use the naming convention `__compound:<name>__`.
-     */
-    getCompoundIndexPartition(tenant, compoundIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const partitionName = `__compound:${compoundIndex.name}__`;
-            return (yield this.db.partition(tenant)).partition(partitionName);
-        });
-    }
-    /**
-     * Builds a compound index key from the given indexes and compound index definition.
-     *
-     * Key format: `<prop1>\x01<prop2>\x01...\x01<sortValue>\x00<messageCid>`
-     *
-     * @returns the compound key, or undefined if the indexes don't contain all required properties.
-     */
-    static buildCompoundKey(messageCid, indexes, compoundIndex) {
-        const segments = [];
-        for (const property of compoundIndex.properties) {
-            const value = indexes[property];
-            if (value === undefined || Array.isArray(value)) {
-                return undefined; // compound indexes don't support array values or missing properties
-            }
-            segments.push(IndexLevel.encodeValue(value));
-        }
-        const sortValue = indexes[compoundIndex.sortProperty];
-        if (sortValue === undefined || Array.isArray(sortValue)) {
-            return undefined;
-        }
-        // join prefix segments with \x01, then append sort value and messageCid with the standard delimiters
-        const prefixPart = segments.join(COMPOUND_SEGMENT_SEPARATOR);
-        const sortPart = IndexLevel.encodeValue(sortValue);
-        return prefixPart + COMPOUND_SEGMENT_SEPARATOR + sortPart + IndexLevel.delimiter + messageCid;
-    }
-    /**
-     * Builds the prefix portion of a compound key from filter values (without the sort/messageCid suffix).
-     * Used for range scans: all entries with this prefix match the filter.
-     */
-    static buildCompoundPrefix(filter, compoundIndex) {
-        const segments = [];
-        for (const property of compoundIndex.properties) {
-            const filterValue = filter[property];
-            if (filterValue === undefined || typeof filterValue === 'object') {
-                return undefined; // compound prefix only works with equality filters
-            }
-            segments.push(IndexLevel.encodeValue(filterValue));
-        }
-        return segments.join(COMPOUND_SEGMENT_SEPARATOR) + COMPOUND_SEGMENT_SEPARATOR;
-    }
-    /**
-     * Creates a put operation for a compound index entry.
-     * Returns undefined if the indexes don't contain all required compound index properties.
-     */
-    createCompoundIndexPutOperation(tenant, item, compoundIndex) {
-        const key = IndexLevel.buildCompoundKey(item.messageCid, item.indexes, compoundIndex);
-        if (key === undefined) {
-            return undefined;
-        }
-        return this.createOperationForPartition(tenant, `__compound:${compoundIndex.name}__`, {
-            type: 'put',
-            key,
-            value: JSON.stringify(item),
-        });
-    }
-    /**
-     * Creates a delete operation for a compound index entry.
-     * Returns undefined if the indexes don't contain all required compound index properties.
-     */
-    createCompoundIndexDeleteOperation(tenant, messageCid, indexes, compoundIndex) {
-        const key = IndexLevel.buildCompoundKey(messageCid, indexes, compoundIndex);
-        if (key === undefined) {
-            return undefined;
-        }
-        return this.createOperationForPartition(tenant, `__compound:${compoundIndex.name}__`, {
-            type: 'del',
-            key,
-        });
-    }
-    /**
-     * Generic helper to create a batch operation for any named partition under a tenant.
-     */
-    createOperationForPartition(tenant, partitionName, operation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tenantPartition = yield this.db.partition(tenant);
-            return tenantPartition.createPartitionOperation(partitionName, operation);
-        });
-    }
-    /**
-     * Selects the best compound index that covers the given filter and sort requirements.
-     *
-     * A compound index "covers" a query when:
-     * 1. Every property in the compound index definition is present in the filter as an equality filter.
-     * 2. The compound index's sort property matches the query's sort property.
-     *
-     * Among multiple matching compound indexes, the one with the most properties is preferred
-     * (more specific = fewer false positives in the prefix scan).
-     */
-    selectCompoundIndex(filter, queryOptions) {
-        let bestMatch;
-        let bestPropertyCount = 0;
-        for (const compoundIndex of this._compoundIndexes) {
-            // check that the sort property matches
-            if (compoundIndex.sortProperty !== queryOptions.sortProperty) {
-                continue;
-            }
-            // check that all compound properties are present in the filter as equality filters
-            let allPropertiesMatch = true;
-            for (const property of compoundIndex.properties) {
-                const filterValue = filter[property];
-                if (filterValue === undefined || typeof filterValue === 'object') {
-                    allPropertiesMatch = false;
-                    break;
-                }
-            }
-            if (allPropertiesMatch && compoundIndex.properties.length > bestPropertyCount) {
-                bestMatch = compoundIndex;
-                bestPropertyCount = compoundIndex.properties.length;
-            }
-        }
-        return bestMatch;
-    }
-    /**
-     * Queries using a compound index. This is the most efficient query strategy: a single LevelDB
-     * range scan that filters, sorts, and paginates all at once.
-     *
-     * The compound key encodes the filter properties as a prefix and the sort property as a suffix,
-     * so iterating over keys with the filter prefix yields results in sort order.
-     *
-     * Any remaining filter properties not covered by the compound index are verified in memory.
-     */
-    queryWithCompoundIndex(tenant, filter, queryOptions, compoundIndex, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_6, _b, _c;
-            const { sortDirection = SortDirection.Ascending, cursor, limit } = queryOptions;
-            const prefix = IndexLevel.buildCompoundPrefix(filter, compoundIndex);
-            if (prefix === undefined) {
-                // should not happen since selectCompoundIndex already validated, but guard against it
-                return this.queryWithIteratorPaging(tenant, [filter], queryOptions, options);
-            }
-            const partition = yield this.getCompoundIndexPartition(tenant, compoundIndex);
-            // determine the iterator bounds from the prefix
-            const iteratorOptions = {};
-            if (cursor !== undefined) {
-                // build the full compound key for the cursor position
-                const cursorSortEncoded = IndexLevel.encodeValue(cursor.value);
-                const cursorKey = prefix + cursorSortEncoded + IndexLevel.delimiter + cursor.messageCid;
-                if (sortDirection === SortDirection.Ascending) {
-                    iteratorOptions.gt = cursorKey;
-                    // upper bound: everything with this prefix (prefix + \xff is past all valid compound keys with this prefix)
-                    iteratorOptions.lt = prefix + '\xff';
-                }
-                else {
-                    iteratorOptions.lt = cursorKey;
-                    iteratorOptions.gt = prefix;
-                    iteratorOptions.reverse = true;
-                }
-            }
-            else {
-                if (sortDirection === SortDirection.Ascending) {
-                    iteratorOptions.gt = prefix;
-                    iteratorOptions.lt = prefix + '\xff';
-                }
-                else {
-                    // for descending without cursor, start from the end of the prefix range
-                    iteratorOptions.gt = prefix;
-                    iteratorOptions.lt = prefix + '\xff';
-                    iteratorOptions.reverse = true;
-                }
-            }
-            // determine which filter properties are NOT covered by the compound index
-            // (need in-memory verification for these)
-            // NOTE: the compound index equality properties are fully covered by the prefix scan,
-            // but the sort property is only covered for ordering — any range filter on the sort
-            // property must still be applied as a residual filter.
-            const coveredEqualityProperties = new Set(compoundIndex.properties);
-            const residualFilter = {};
-            let hasResidualFilter = false;
-            for (const property in filter) {
-                if (!coveredEqualityProperties.has(property)) {
-                    residualFilter[property] = filter[property];
-                    hasResidualFilter = true;
-                }
-            }
-            const matches = [];
-            try {
-                for (var _d = true, _e = __asyncValues(partition.iterator(iteratorOptions, options)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const [_key, value] = _c;
-                    if (limit !== undefined && matches.length === limit) {
-                        break;
-                    }
-                    const item = JSON.parse(value);
-                    // verify any residual filter properties in memory
-                    if (hasResidualFilter && !FilterUtility.matchFilter(item.indexes, residualFilter)) {
-                        continue;
-                    }
-                    matches.push(item);
-                }
-            }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_6) throw e_6.error; }
-            }
-            return matches;
-        });
-    }
-    /**
-     * Counts items matching a compound index prefix without loading full records.
-     * Iterates only keys (not values) for maximum efficiency.
-     */
-    countWithCompoundIndex(tenant, filter, compoundIndex, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_7, _b, _c, _d, e_8, _e, _f;
-            const prefix = IndexLevel.buildCompoundPrefix(filter, compoundIndex);
-            if (prefix === undefined) {
-                // fallback
-                const results = yield this.query(tenant, [filter], { sortProperty: compoundIndex.sortProperty }, options);
-                return results.length;
-            }
-            const partition = yield this.getCompoundIndexPartition(tenant, compoundIndex);
-            // determine which filter properties are NOT covered by the compound index
-            // (same logic as queryWithCompoundIndex: sort property range filters are residual)
-            const coveredEqualityProperties = new Set(compoundIndex.properties);
-            let hasResidualFilter = false;
-            const residualFilter = {};
-            for (const property in filter) {
-                if (!coveredEqualityProperties.has(property)) {
-                    residualFilter[property] = filter[property];
-                    hasResidualFilter = true;
-                }
-            }
-            const iteratorOptions = {
-                gt: prefix,
-                lt: prefix + '\xff',
-            };
-            let count = 0;
-            if (hasResidualFilter) {
-                try {
-                    // must read values to check residual filter
-                    for (var _g = true, _h = __asyncValues(partition.iterator(iteratorOptions, options)), _j; _j = yield _h.next(), _a = _j.done, !_a; _g = true) {
-                        _c = _j.value;
-                        _g = false;
-                        const [_key, value] = _c;
-                        const item = JSON.parse(value);
-                        if (FilterUtility.matchFilter(item.indexes, residualFilter)) {
-                            count++;
-                        }
-                    }
-                }
-                catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                finally {
-                    try {
-                        if (!_g && !_a && (_b = _h.return)) yield _b.call(_h);
-                    }
-                    finally { if (e_7) throw e_7.error; }
-                }
-            }
-            else {
-                try {
-                    // no residual filter — iterate keys via iterator without parsing values
-                    for (var _k = true, _l = __asyncValues(partition.iterator(iteratorOptions, options)), _m; _m = yield _l.next(), _d = _m.done, !_d; _k = true) {
-                        _f = _m.value;
-                        _k = false;
-                        const [_key, _value] = _f;
-                        count++;
-                    }
-                }
-                catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                finally {
-                    try {
-                        if (!_k && !_d && (_e = _l.return)) yield _e.call(_l);
-                    }
-                    finally { if (e_8) throw e_8.error; }
-                }
-            }
-            return count;
-        });
-    }
-    // =========================================================================
     // Query strategy selection
     // =========================================================================
     static shouldQueryWithInMemoryPaging(filters, queryOptions) {
@@ -1011,8 +597,4 @@ export class IndexLevel {
         return false;
     }
 }
-/**
- * Joins the given values using the `\x00` (\u0000) character.
- */
-IndexLevel.delimiter = `\x00`;
 //# sourceMappingURL=index-level.js.map