@yoch/frozenminisearch 1.0.0

package/dist/cjs/index.cjs

@@ -0,0 +1,4350 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var zlib = require('node:zlib');
+
+const MAX_FREQ = 65535;
+function readDocId(docIds, index) {
+    return docIds[index];
+}
+function allocateFreqs(length, maxValue) {
+    if (maxValue <= 0xff)
+        return new Uint8Array(length);
+    return new Uint16Array(length);
+}
+/**
+ * Clamp term frequency for frozen flat storage (max Uint16).
+ * Values above {@link MAX_FREQ} are rare; BM25+ contribution is already flat well below that.
+ */
+function clampFreq(freq) {
+    return freq > MAX_FREQ ? MAX_FREQ : freq;
+}
+/** View into global flat posting buffers (no per-list allocation). */
+class SegmentPostingList {
+    constructor(docIds, freqs, offset, length) {
+        this.docIds = docIds;
+        this.freqs = freqs;
+        this._offset = offset;
+        this._length = length;
+    }
+    get offset() {
+        return this._offset;
+    }
+    get length() {
+        return this._length;
+    }
+    /** Rebind this view to another segment in the same global buffers (flyweight use). */
+    rebind(offset, length) {
+        this._offset = offset;
+        this._length = length;
+        return this;
+    }
+    get size() {
+        return this._length;
+    }
+    forEachDoc(callback) {
+        const { docIds, freqs, offset, length } = this;
+        for (let i = 0; i < length; i++) {
+            callback(readDocId(docIds, offset + i), freqs[offset + i]);
+        }
+    }
+}
+
+/**
+ * Wildcard query symbol (matches all documents).
+ * Use {@link FrozenMiniSearch.wildcard} in application code.
+ */
+const WILDCARD_QUERY = Symbol('*');
+/** True only for this package's wildcard symbol (strict identity, not description). */
+function isWildcardQuery(query) {
+    return query === WILDCARD_QUERY;
+}
+
+const OR = 'or';
+const AND = 'and';
+const AND_NOT = 'and_not';
+const defaultBM25params = { k: 1.2, b: 0.7, d: 0.5 };
+function bm25FieldConstants(bm25params, avgFieldLength) {
+    const { k, b, d } = bm25params;
+    return { k, d, k1: k + 1, oneMinusB: 1 - b, bOverAvg: b / avgFieldLength };
+}
+function calcBM25ScoreWithConstants(termFreq, matchingCount, totalCount, fieldLength, constants) {
+    const { k, d, k1, oneMinusB, bOverAvg } = constants;
+    const invDocFreq = Math.log(1 + (totalCount - matchingCount + 0.5) / (matchingCount + 0.5));
+    return invDocFreq * (d + termFreq * k1 / (termFreq + k * (oneMinusB + bOverAvg * fieldLength)));
+}
+const getOwnProperty = (object, property) => Object.prototype.hasOwnProperty.call(object, property) ? object[property] : undefined;
+function fieldBoostsForQuery(options, fields) {
+    const searchFields = options.fields || fields;
+    const boosts = {};
+    for (const field of searchFields) {
+        boosts[field] = getOwnProperty(options.boost, field) || 1;
+    }
+    return { names: Object.keys(boosts), boosts };
+}
+const assignUniqueTerm = (target, term) => {
+    if (!target.includes(term))
+        target.push(term);
+};
+const assignUniqueTerms = (target, source) => {
+    for (const term of source) {
+        if (!target.includes(term))
+            target.push(term);
+    }
+};
+const byScore = ({ score: a }, { score: b }) => b - a;
+function getDerivedTerm(derivedTerm, cache) {
+    if (typeof derivedTerm === 'string')
+        return derivedTerm;
+    if (cache.value === undefined)
+        cache.value = derivedTerm.resolve();
+    return cache.value;
+}
+function scorePostingDoc(sourceTerm, derivedTerm, field, fieldId, docId, termFreq, termWeight, termBoost, fieldBoost, matchingFields, context, boostDocumentFn, bm25, results, derivedTermCache) {
+    const resolvedDerivedTerm = getDerivedTerm(derivedTerm, derivedTermCache);
+    const docBoost = boostDocumentFn
+        ? boostDocumentFn(context.getExternalId(docId), resolvedDerivedTerm, context.getStoredFields(docId))
+        : 1;
+    if (!docBoost)
+        return;
+    const fieldLength = context.getFieldLength(docId, fieldId);
+    const rawScore = calcBM25ScoreWithConstants(termFreq, matchingFields, context.documentCount, fieldLength, bm25);
+    const weightedScore = termWeight * termBoost * fieldBoost * docBoost * rawScore;
+    const result = results.get(docId);
+    if (result) {
+        result.score += weightedScore;
+        assignUniqueTerm(result.terms, sourceTerm);
+        const match = getOwnProperty(result.match, resolvedDerivedTerm);
+        if (match) {
+            match.push(field);
+        }
+        else {
+            result.match[resolvedDerivedTerm] = [field];
+        }
+    }
+    else {
+        results.set(docId, {
+            score: weightedScore,
+            terms: [sourceTerm],
+            match: { [resolvedDerivedTerm]: [field] },
+        });
+    }
+}
+function aggregateSegmentPostingList(sourceTerm, derivedTerm, termWeight, termBoost, field, fieldId, fieldBoost, list, context, boostDocumentFn, bm25params, results, allowedDocs) {
+    var _a;
+    let matchingFields = list.length;
+    const bm25 = bm25FieldConstants(bm25params, context.avgFieldLength[fieldId]);
+    const { docIds, freqs, offset, length } = list;
+    const derivedTermCache = {};
+    for (let i = 0; i < length; i++) {
+        const docId = readDocId(docIds, offset + i);
+        const termFreq = freqs[offset + i];
+        if (context.isDocActive != null && !context.isDocActive(docId)) {
+            (_a = context.onInactiveDoc) === null || _a === void 0 ? void 0 : _a.call(context, docId, fieldId, getDerivedTerm(derivedTerm, derivedTermCache));
+            matchingFields -= 1;
+            continue;
+        }
+        if (allowedDocs != null && !allowedDocs.has(docId))
+            continue;
+        scorePostingDoc(sourceTerm, derivedTerm, field, fieldId, docId, termFreq, termWeight, termBoost, fieldBoost, matchingFields, context, boostDocumentFn, bm25, results, derivedTermCache);
+    }
+    return matchingFields;
+}
+function aggregateTerm(sourceTerm, derivedTerm, termWeight, termBoost, fieldTermData, fieldBoosts, context, boostDocumentFn, bm25params, results = new Map(), termOptions) {
+    if (fieldTermData == null)
+        return results;
+    const { allowedDocs } = termOptions !== null && termOptions !== void 0 ? termOptions : {};
+    for (const field of fieldBoosts.names) {
+        const fieldBoost = fieldBoosts.boosts[field];
+        const fieldId = context.fieldIds[field];
+        const postingList = fieldTermData.get(fieldId);
+        if (postingList == null)
+            continue;
+        if (postingList instanceof SegmentPostingList) {
+            aggregateSegmentPostingList(sourceTerm, derivedTerm, termWeight, termBoost, field, fieldId, fieldBoost, postingList, context, boostDocumentFn, bm25params, results, allowedDocs);
+            continue;
+        }
+        let matchingFields = postingList.size;
+        const bm25 = bm25FieldConstants(bm25params, context.avgFieldLength[fieldId]);
+        const derivedTermCache = {};
+        postingList.forEachDoc((docId, termFreq) => {
+            var _a;
+            if (context.isDocActive != null && !context.isDocActive(docId)) {
+                (_a = context.onInactiveDoc) === null || _a === void 0 ? void 0 : _a.call(context, docId, fieldId, getDerivedTerm(derivedTerm, derivedTermCache));
+                matchingFields -= 1;
+                return;
+            }
+            if (allowedDocs != null && !allowedDocs.has(docId))
+                return;
+            scorePostingDoc(sourceTerm, derivedTerm, field, fieldId, docId, termFreq, termWeight, termBoost, fieldBoost, matchingFields, context, boostDocumentFn, bm25, results, derivedTermCache);
+        });
+    }
+    return results;
+}
+const combinators = {
+    [OR]: (a, b) => {
+        for (const docId of b.keys()) {
+            const existing = a.get(docId);
+            if (existing == null) {
+                a.set(docId, b.get(docId));
+            }
+            else {
+                const { score, terms, match } = b.get(docId);
+                existing.score = existing.score + score;
+                existing.match = Object.assign(existing.match, match);
+                assignUniqueTerms(existing.terms, terms);
+            }
+        }
+        return a;
+    },
+    [AND]: (a, b) => {
+        for (const docId of a.keys()) {
+            const inB = b.get(docId);
+            if (inB == null) {
+                a.delete(docId);
+                continue;
+            }
+            const existing = a.get(docId);
+            const { score, terms, match } = inB;
+            existing.score += score;
+            assignUniqueTerms(existing.terms, terms);
+            Object.assign(existing.match, match);
+        }
+        return a;
+    },
+    [AND_NOT]: (a, b) => {
+        for (const docId of b.keys())
+            a.delete(docId);
+        return a;
+    },
+};
+/**
+ * Combines per-term raw results. Mutates `results[0]` in place (OR/AND/AND_NOT); do not reuse
+ * other entries in `results` after this call.
+ */
+function combineResults(results, combineWith = OR) {
+    if (results.length === 0)
+        return new Map();
+    const operator = combineWith.toLowerCase();
+    const combinator = combinators[operator];
+    if (!combinator) {
+        throw new Error(`Invalid combination operator: ${combineWith}`);
+    }
+    return results.reduce(combinator);
+}
+/** Merge search options, apply wildcard skipSort, then {@link finalizeSearchResults}. */
+function finalizeRawSearchResults(rawResults, query, searchOptions, globalSearchOptions, getExternalId, getStoredFields) {
+    const searchOptionsWithDefaults = {
+        ...globalSearchOptions,
+        ...searchOptions,
+    };
+    const skipSort = isWildcardQuery(query) && searchOptionsWithDefaults.boostDocument == null;
+    return finalizeSearchResults({
+        rawResults,
+        getExternalId,
+        getStoredFields,
+        filter: searchOptionsWithDefaults.filter,
+        skipSort,
+    });
+}
+function finalizeSearchResults(params) {
+    const { rawResults, getExternalId, getStoredFields, filter, skipSort } = params;
+    const results = [];
+    for (const [docId, { score, terms, match }] of rawResults) {
+        const quality = terms.length || 1;
+        const result = {
+            id: getExternalId(docId),
+            score: score * quality,
+            terms: Object.keys(match),
+            queryTerms: terms,
+            match,
+        };
+        Object.assign(result, getStoredFields(docId));
+        if (filter == null || filter(result)) {
+            results.push(result);
+        }
+    }
+    if (!skipSort) {
+        results.sort(byScore);
+    }
+    return results;
+}
+const termToQuerySpec = (options) => (term, i, terms) => {
+    const fuzzy = (typeof options.fuzzy === 'function')
+        ? options.fuzzy(term, i, terms)
+        : (options.fuzzy || false);
+    const prefix = (typeof options.prefix === 'function')
+        ? options.prefix(term, i, terms)
+        : (options.prefix === true);
+    const termBoost = (typeof options.boostTerm === 'function')
+        ? options.boostTerm(term, i, terms)
+        : 1;
+    return { term, fuzzy, prefix, termBoost };
+};
+
+/**
+ * Build-time scratch marker for "node carries no leaf" while assembling a tree
+ * from a mutable `RadixTree` or a decoded binary section. It is *not* stored in
+ * the packed arrays: there, the absence of a leaf is encoded by
+ * `nodeLeafOrder === 0` (see {@link PackedRadixTreeData.nodeLeafOrder}), which
+ * frees `nodeValue` from carrying a sentinel and lets both columns use the
+ * narrowest typed array.
+ */
+const PACKED_NO_VALUE = 0xffffffff;
+/** Max UTF-16 length of a single edge label. */
+const MAX_PACKED_EDGE_LABEL_LENGTH = 0xffff;
+
+/**
+ * Allocate the narrowest unsigned typed array that can hold every value in
+ * `[0, maxValue]`. Mirrors the adaptive width choice already used for frozen
+ * postings (Uint16 vs Uint32), trading nothing at read time for a smaller
+ * footprint on the common small/medium index.
+ */
+function packedIndexArray(length, maxValue) {
+    if (maxValue <= 0xff)
+        return new Uint8Array(length);
+    if (maxValue <= 0xffff)
+        return new Uint16Array(length);
+    return new Uint32Array(length);
+}
+/**
+ * Decode a stored `nodeLeafOrder` cell into a sibling slot: `-1` when the node
+ * has no leaf, otherwise the leaf's slot among its siblings. The stored value
+ * is `slot + 1` (0 = no leaf), so plain subtraction recovers both cases.
+ */
+function decodeLeafSlot(storedLeafOrder) {
+    return storedLeafOrder - 1;
+}
+/**
+ * Number of logical children for a node: radix edges plus optional leaf slot.
+ */
+function packedNodeChildCount(edgeCount, hasLeaf) {
+    return edgeCount + (hasLeaf ? 1 : 0);
+}
+/**
+ * Map a logical child slot (including optional leaf) to the edge offset.
+ * `leafSlot` is the decoded slot (`-1` when the node has no leaf).
+ *
+ * Returns `-1` when `slot` points to the leaf.
+ */
+function edgeOffsetAtSlot(slot, leafSlot) {
+    if (slot === leafSlot)
+        return -1;
+    return slot - (leafSlot >= 0 && leafSlot < slot ? 1 : 0);
+}
+
+/** Validate packed-tree invariants for a frozen index (term indices in `[0, termCount)`). */
+function validateFrozenTermIndexLeaves(tree, termCount) {
+    if (tree.nodeEdgeOffset.length !== tree.nodeCount + 1
+        || tree.nodeValue.length !== tree.nodeCount
+        || tree.nodeLeafOrder.length !== tree.nodeCount
+        || tree.edgeLabelStart.length !== tree.edgeCount
+        || tree.edgeLabelLength.length !== tree.edgeCount
+        || tree.edgeChild.length !== tree.edgeCount) {
+        throw new Error('FrozenTermIndex: array length mismatch');
+    }
+    if (tree.nodeCount === 0) {
+        throw new Error('FrozenTermIndex: missing root node');
+    }
+    if (tree.nodeEdgeOffset[0] !== 0 || tree.nodeEdgeOffset[tree.nodeCount] !== tree.edgeCount) {
+        throw new Error('FrozenTermIndex: edge offsets not bounded by [0, edgeCount]');
+    }
+    const seenLeaves = new Uint8Array(termCount);
+    let leafCount = 0;
+    for (let node = 0; node < tree.nodeCount; node++) {
+        const first = tree.nodeEdgeOffset[node];
+        const count = tree.nodeEdgeOffset[node + 1] - first;
+        if (count < 0) {
+            throw new Error(`FrozenTermIndex: node ${node} edge offsets not monotonic`);
+        }
+        const leafSlot = decodeLeafSlot(tree.nodeLeafOrder[node]);
+        if (leafSlot < 0) {
+            if (tree.nodeValue[node] !== 0) {
+                throw new Error(`FrozenTermIndex: node ${node} has value without leaf`);
+            }
+            continue;
+        }
+        if (leafSlot >= count + 1) {
+            throw new Error(`FrozenTermIndex: node ${node} leaf order out of bounds`);
+        }
+        leafCount++;
+        const v = tree.nodeValue[node];
+        if (!Number.isInteger(v) || v < 0 || v >= termCount) {
+            throw new Error(`FrozenTermIndex: leaf index out of range: ${v}`);
+        }
+        if (seenLeaves[v] !== 0) {
+            throw new Error(`FrozenTermIndex: duplicate leaf index: ${v}`);
+        }
+        seenLeaves[v] = 1;
+    }
+    for (let edge = 0; edge < tree.edgeCount; edge++) {
+        const start = tree.edgeLabelStart[edge];
+        const len = tree.edgeLabelLength[edge];
+        if (len === 0 || len > MAX_PACKED_EDGE_LABEL_LENGTH || start + len > tree.labelHeap.length) {
+            throw new Error(`FrozenTermIndex: edge ${edge} label range out of bounds`);
+        }
+        if (tree.edgeChild[edge] >= tree.nodeCount) {
+            throw new Error(`FrozenTermIndex: edge ${edge} child out of bounds`);
+        }
+    }
+    if (leafCount !== termCount) {
+        throw new Error(`FrozenTermIndex: leaf count ${leafCount} !== termCount ${termCount}`);
+    }
+    if (tree.size !== termCount) {
+        throw new Error(`FrozenTermIndex: size ${tree.size} !== termCount ${termCount}`);
+    }
+}
+
+/** @ignore */
+const ENTRIES = 'ENTRIES';
+/** @ignore */
+const KEYS = 'KEYS';
+/** @ignore */
+const VALUES = 'VALUES';
+/** @ignore */
+const LEAF = '';
+/**
+ * @private
+ */
+class TreeIterator {
+    constructor(set, type) {
+        const node = set._tree;
+        const keys = Array.from(node.keys());
+        this.set = set;
+        this._type = type;
+        this._path = keys.length > 0 ? [{ node, keys }] : [];
+    }
+    next() {
+        const value = this.dive();
+        this.backtrack();
+        return value;
+    }
+    dive() {
+        if (this._path.length === 0) {
+            return { done: true, value: undefined };
+        }
+        const { node, keys } = last$1(this._path);
+        if (last$1(keys) === LEAF) {
+            return { done: false, value: this.result() };
+        }
+        const child = node.get(last$1(keys));
+        this._path.push({ node: child, keys: Array.from(child.keys()) });
+        return this.dive();
+    }
+    backtrack() {
+        if (this._path.length === 0) {
+            return;
+        }
+        const keys = last$1(this._path).keys;
+        keys.pop();
+        if (keys.length > 0) {
+            return;
+        }
+        this._path.pop();
+        this.backtrack();
+    }
+    key() {
+        return this.set._prefix + this._path
+            .map(({ keys }) => last$1(keys))
+            .filter(key => key !== LEAF)
+            .join('');
+    }
+    value() {
+        return last$1(this._path).node.get(LEAF);
+    }
+    result() {
+        switch (this._type) {
+            case VALUES: return this.value();
+            case KEYS: return this.key();
+            default: return [this.key(), this.value()];
+        }
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+const last$1 = (array) => {
+    return array[array.length - 1];
+};
+
+/**
+ * Length bounds for fuzzy radix traversal (B1).
+ * Only prunes when the dictionary prefix cannot be a prefix of any match.
+ */
+/** Dictionary prefix length already exceeds any term within edit distance k. */
+function isDictPrefixTooLong(dictPrefixLen, queryLen, maxDistance) {
+    return dictPrefixLen > queryLen + maxDistance;
+}
+/**
+ * @param prefixLen Dictionary characters on the path before this edge
+ * @param edgeLen Compressed edge label length
+ */
+function shouldPruneFuzzyEdge(prefixLen, edgeLen, queryLen, maxDistance) {
+    return isDictPrefixTooLong(prefixLen + edgeLen, queryLen, maxDistance);
+}
+
+/* eslint-disable no-labels */
+/**
+ * @ignore
+ */
+const fuzzySearch = (node, query, maxDistance) => {
+    const results = new Map();
+    if (query === undefined)
+        return results;
+    // Number of columns in the Levenshtein matrix.
+    const n = query.length + 1;
+    // Matching terms can never be longer than N + maxDistance.
+    const m = n + maxDistance;
+    // Fill first matrix row and column with numbers: 0 1 2 3 ...
+    const matrix = new Uint8Array(m * n).fill(maxDistance + 1);
+    for (let j = 0; j < n; ++j)
+        matrix[j] = j;
+    for (let i = 1; i < m; ++i)
+        matrix[i * n] = i;
+    recurse$1(node, query, maxDistance, results, matrix, 1, n, '');
+    return results;
+};
+// Modified version of http://stevehanov.ca/blog/?id=114
+const recurse$1 = (node, query, maxDistance, results, matrix, m, n, prefix) => {
+    const offset = m * n;
+    key: for (const key of node.keys()) {
+        if (key === LEAF) {
+            const distance = matrix[offset - 1];
+            if (distance <= maxDistance) {
+                results.set(prefix, [node.get(key), distance]);
+            }
+        }
+        else {
+            // m = next matrix row index; dictionary prefix on path has length m - 1
+            if (shouldPruneFuzzyEdge(m - 1, key.length, query.length, maxDistance)) {
+                continue key;
+            }
+            let i = m;
+            for (let pos = 0; pos < key.length; ++pos, ++i) {
+                const char = key[pos];
+                const thisRowOffset = n * i;
+                const prevRowOffset = thisRowOffset - n;
+                let minDistance = matrix[thisRowOffset];
+                const jmin = Math.max(0, i - maxDistance - 1);
+                const jmax = Math.min(n - 1, i + maxDistance);
+                for (let j = jmin; j < jmax; ++j) {
+                    const different = char !== query[j];
+                    const rpl = matrix[prevRowOffset + j] + +different;
+                    const del = matrix[prevRowOffset + j + 1] + 1;
+                    const ins = matrix[thisRowOffset + j] + 1;
+                    const dist = matrix[thisRowOffset + j + 1] = Math.min(rpl, del, ins);
+                    if (dist < minDistance)
+                        minDistance = dist;
+                }
+                if (minDistance > maxDistance) {
+                    continue key;
+                }
+            }
+            recurse$1(node.get(key), query, maxDistance, results, matrix, i, n, prefix + key);
+        }
+    }
+};
+
+/* eslint-disable no-labels */
+/**
+ * A class implementing the same interface as a standard JavaScript
+ * [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)
+ * with string keys, but adding support for efficiently searching entries with
+ * prefix or fuzzy search. This class is used internally by {@link MiniSearch}
+ * as the inverted index data structure. The implementation is a radix tree
+ * (compressed prefix tree).
+ *
+ * Since this class can be of general utility beyond _MiniSearch_, it is
+ * internal to `@yoch/frozenminisearch` (not a separate public entry point).
+ *
+ * @typeParam T  The type of the values stored in the map.
+ */
+class SearchableMap {
+    /**
+     * The constructor is normally called without arguments, creating an empty
+     * map. In order to create a {@link SearchableMap} from an iterable or from an
+     * object, check {@link SearchableMap.from} and {@link
+     * SearchableMap.fromObject}.
+     *
+     * The constructor arguments are for internal use, when creating derived
+     * mutable views of a map at a prefix.
+     */
+    constructor(tree = new Map(), prefix = '') {
+        this._size = undefined;
+        this._tree = tree;
+        this._prefix = prefix;
+    }
+    /**
+     * Root radix tree backing this map. Used when cloning or serializing the full
+     * index so {@link Map} key insertion order (prefix / fuzzy / autoSuggest) is preserved.
+     */
+    get radixTree() {
+        return this._tree;
+    }
+    /**
+     * Creates and returns a mutable view of this {@link SearchableMap},
+     * containing only entries that share the given prefix.
+     *
+     * ### Usage:
+     *
+     * ```javascript
+     * let map = new SearchableMap()
+     * map.set("unicorn", 1)
+     * map.set("universe", 2)
+     * map.set("university", 3)
+     * map.set("unique", 4)
+     * map.set("hello", 5)
+     *
+     * let uni = map.atPrefix("uni")
+     * uni.get("unique") // => 4
+     * uni.get("unicorn") // => 1
+     * uni.get("hello") // => undefined
+     *
+     * let univer = map.atPrefix("univer")
+     * univer.get("unique") // => undefined
+     * univer.get("universe") // => 2
+     * univer.get("university") // => 3
+     * ```
+     *
+     * @param prefix  The prefix
+     * @return A {@link SearchableMap} representing a mutable view of the original
+     * Map at the given prefix
+     */
+    atPrefix(prefix) {
+        if (!prefix.startsWith(this._prefix)) {
+            throw new Error('Mismatched prefix');
+        }
+        const [node, path] = trackDown(this._tree, prefix.slice(this._prefix.length));
+        if (node === undefined) {
+            const [parentNode, key] = last(path);
+            for (const k of parentNode.keys()) {
+                if (k !== LEAF && k.startsWith(key)) {
+                    const node = new Map();
+                    node.set(k.slice(key.length), parentNode.get(k));
+                    return new SearchableMap(node, prefix);
+                }
+            }
+        }
+        return new SearchableMap(node, prefix);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear
+     */
+    clear() {
+        this._size = undefined;
+        this._tree.clear();
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete
+     * @param key  Key to delete
+     */
+    delete(key) {
+        this._size = undefined;
+        return remove(this._tree, key);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries
+     * @return An iterator iterating through `[key, value]` entries.
+     */
+    entries() {
+        return new TreeIterator(this, ENTRIES);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach
+     * @param fn  Iteration function
+     */
+    forEach(fn) {
+        for (const [key, value] of this) {
+            fn(key, value, this);
+        }
+    }
+    /**
+     * Returns a Map of all the entries that have a key within the given edit
+     * distance from the search key. The keys of the returned Map are the matching
+     * keys, while the values are two-element arrays where the first element is
+     * the value associated to the key, and the second is the edit distance of the
+     * key to the search key.
+     *
+     * ### Usage:
+     *
+     * ```javascript
+     * let map = new SearchableMap()
+     * map.set('hello', 'world')
+     * map.set('hell', 'yeah')
+     * map.set('ciao', 'mondo')
+     *
+     * // Get all entries that match the key 'hallo' with a maximum edit distance of 2
+     * map.fuzzyGet('hallo', 2)
+     * // => Map(2) { 'hello' => ['world', 1], 'hell' => ['yeah', 2] }
+     *
+     * // In the example, the "hello" key has value "world" and edit distance of 1
+     * // (change "e" to "a"), the key "hell" has value "yeah" and edit distance of 2
+     * // (change "e" to "a", delete "o")
+     * ```
+     *
+     * @param key  The search key
+     * @param maxEditDistance  The maximum edit distance (Levenshtein)
+     * @return A Map of the matching keys to their value and edit distance
+     */
+    fuzzyGet(key, maxEditDistance) {
+        return fuzzySearch(this._tree, key, maxEditDistance);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get
+     * @param key  Key to get
+     * @return Value associated to the key, or `undefined` if the key is not
+     * found.
+     */
+    get(key) {
+        const node = lookup(this._tree, key);
+        return node !== undefined ? node.get(LEAF) : undefined;
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has
+     * @param key  Key
+     * @return True if the key is in the map, false otherwise
+     */
+    has(key) {
+        const node = lookup(this._tree, key);
+        return node !== undefined && node.has(LEAF);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys
+     * @return An `Iterable` iterating through keys
+     */
+    keys() {
+        return new TreeIterator(this, KEYS);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set
+     * @param key  Key to set
+     * @param value  Value to associate to the key
+     * @return The {@link SearchableMap} itself, to allow chaining
+     */
+    set(key, value) {
+        if (typeof key !== 'string') {
+            throw new Error('key must be a string');
+        }
+        this._size = undefined;
+        const node = createPath(this._tree, key);
+        node.set(LEAF, value);
+        return this;
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size
+     */
+    get size() {
+        if (this._size !== undefined) {
+            return this._size;
+        }
+        /** @ignore */
+        this._size = 0;
+        const iter = this.entries();
+        while (!iter.next().done)
+            this._size += 1;
+        return this._size;
+    }
+    /**
+     * Updates the value at the given key using the provided function. The function
+     * is called with the current value at the key, and its return value is used as
+     * the new value to be set.
+     *
+     * ### Example:
+     *
+     * ```javascript
+     * // Increment the current value by one
+     * searchableMap.update('somekey', (currentValue) => currentValue == null ? 0 : currentValue + 1)
+     * ```
+     *
+     * If the value at the given key is or will be an object, it might not require
+     * re-assignment. In that case it is better to use `fetch()`, because it is
+     * faster.
+     *
+     * @param key  The key to update
+     * @param fn  The function used to compute the new value from the current one
+     * @return The {@link SearchableMap} itself, to allow chaining
+     */
+    update(key, fn) {
+        if (typeof key !== 'string') {
+            throw new Error('key must be a string');
+        }
+        this._size = undefined;
+        const node = createPath(this._tree, key);
+        node.set(LEAF, fn(node.get(LEAF)));
+        return this;
+    }
+    /**
+     * Fetches the value of the given key. If the value does not exist, calls the
+     * given function to create a new value, which is inserted at the given key
+     * and subsequently returned.
+     *
+     * ### Example:
+     *
+     * ```javascript
+     * const map = searchableMap.fetch('somekey', () => new Map())
+     * map.set('foo', 'bar')
+     * ```
+     *
+     * @param key  The key to update
+     * @param initial  A function that creates a new value if the key does not exist
+     * @return The existing or new value at the given key
+     */
+    fetch(key, initial) {
+        if (typeof key !== 'string') {
+            throw new Error('key must be a string');
+        }
+        this._size = undefined;
+        const node = createPath(this._tree, key);
+        let value = node.get(LEAF);
+        if (value === undefined) {
+            node.set(LEAF, value = initial());
+        }
+        return value;
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values
+     * @return An `Iterable` iterating through values.
+     */
+    values() {
+        return new TreeIterator(this, VALUES);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@iterator
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * Creates a {@link SearchableMap} from an `Iterable` of entries
+     *
+     * @param entries  Entries to be inserted in the {@link SearchableMap}
+     * @return A new {@link SearchableMap} with the given entries
+     */
+    static from(entries) {
+        const tree = new SearchableMap();
+        for (const [key, value] of entries) {
+            tree.set(key, value);
+        }
+        return tree;
+    }
+    /**
+     * Creates a {@link SearchableMap} from the iterable properties of a JavaScript object
+     *
+     * @param object  Object of entries for the {@link SearchableMap}
+     * @return A new {@link SearchableMap} with the given entries
+     */
+    static fromObject(object) {
+        return SearchableMap.from(Object.entries(object));
+    }
+}
+const trackDown = (tree, key, path = []) => {
+    if (key.length === 0 || tree == null) {
+        return [tree, path];
+    }
+    for (const k of tree.keys()) {
+        if (k !== LEAF && key.startsWith(k)) {
+            path.push([tree, k]); // performance: update in place
+            return trackDown(tree.get(k), key.slice(k.length), path);
+        }
+    }
+    path.push([tree, key]); // performance: update in place
+    return trackDown(undefined, '', path);
+};
+const lookup = (tree, key) => {
+    if (key.length === 0 || tree == null) {
+        return tree;
+    }
+    for (const k of tree.keys()) {
+        if (k !== LEAF && key.startsWith(k)) {
+            return lookup(tree.get(k), key.slice(k.length));
+        }
+    }
+};
+// Create a path in the radix tree for the given key, and returns the deepest
+// node. This function is in the hot path for indexing. It avoids unnecessary
+// string operations and recursion for performance.
+const createPath = (node, key) => {
+    const keyLength = key.length;
+    outer: for (let pos = 0; node && pos < keyLength;) {
+        for (const k of node.keys()) {
+            // Check whether this key is a candidate: the first characters must match.
+            if (k !== LEAF && key[pos] === k[0]) {
+                const len = Math.min(keyLength - pos, k.length);
+                // Advance offset to the point where key and k no longer match.
+                let offset = 1;
+                while (offset < len && key[pos + offset] === k[offset])
+                    ++offset;
+                const child = node.get(k);
+                if (offset === k.length) {
+                    // The existing key is shorter than the key we need to create.
+                    node = child;
+                }
+                else {
+                    // Partial match: we need to insert an intermediate node to contain
+                    // both the existing subtree and the new node.
+                    const intermediate = new Map();
+                    intermediate.set(k.slice(offset), child);
+                    node.set(key.slice(pos, pos + offset), intermediate);
+                    node.delete(k);
+                    node = intermediate;
+                }
+                pos += offset;
+                continue outer;
+            }
+        }
+        // Create a final child node to contain the final suffix of the key.
+        const child = new Map();
+        node.set(key.slice(pos), child);
+        return child;
+    }
+    return node;
+};
+const remove = (tree, key) => {
+    const [node, path] = trackDown(tree, key);
+    if (node === undefined) {
+        return;
+    }
+    node.delete(LEAF);
+    if (node.size === 0) {
+        cleanup(path);
+    }
+    else if (node.size === 1) {
+        const [key, value] = node.entries().next().value;
+        merge(path, key, value);
+    }
+};
+const cleanup = (path) => {
+    if (path.length === 0) {
+        return;
+    }
+    const [node, key] = last(path);
+    node.delete(key);
+    if (node.size === 0) {
+        cleanup(path.slice(0, -1));
+    }
+    else if (node.size === 1) {
+        const [key, value] = node.entries().next().value;
+        if (key !== LEAF) {
+            merge(path.slice(0, -1), key, value);
+        }
+    }
+};
+const merge = (path, key, value) => {
+    if (path.length === 0) {
+        return;
+    }
+    const [node, nodeKey] = last(path);
+    node.set(nodeKey + key, value);
+    node.delete(nodeKey);
+};
+const last = (array) => {
+    return array[array.length - 1];
+};
+
+function labelSlice(heap, start, len) {
+    return heap.slice(start, start + len);
+}
+
+/* eslint-disable no-labels */
+/**
+ * Lazy generator, same Iterable contract as `prefixRefs`. Matches are yielded as
+ * found (no eager `PackedFuzzyRef[]`). Slightly slower than materializing an array
+ * on micro-benches, but keeps the ref-first API uniform and leaves room for future
+ * query push-down (term-level gate skip, early abort). Easy to revert to eager if
+ * that never pays off.
+ */
+function packedRadixFuzzyRefs(tree, query, maxDistance) {
+    return runFuzzy(tree, query, maxDistance);
+}
+/** @deprecated Internal benchmark/compat wrapper. Prefer `packedRadixFuzzyRefs`. */
+function packedRadixFuzzyEntries(tree, query, maxDistance) {
+    const results = [];
+    for (const { termIndex, distance } of packedRadixFuzzyRefs(tree, query, maxDistance)) {
+        results.push([tree.termByIndex(termIndex), termIndex, distance]);
+    }
+    return results;
+}
+function* runFuzzy(tree, query, maxDistance) {
+    if (maxDistance < 0)
+        return;
+    const n = query.length + 1;
+    const m = n + maxDistance;
+    const matrix = new Uint8Array(m * n).fill(maxDistance + 1);
+    for (let j = 0; j < n; ++j)
+        matrix[j] = j;
+    for (let i = 1; i < m; ++i)
+        matrix[i * n] = i;
+    const queryLen = query.length;
+    const queryCodes = new Uint16Array(n);
+    for (let j = 0; j < queryLen; j++)
+        queryCodes[j] = query.charCodeAt(j);
+    yield* recurse(tree, queryLen, queryCodes, maxDistance, matrix, 1, 0, 0);
+}
+function* recurse(tree, queryLen, queryCodes, maxDistance, matrix, rowStart, node, termLength) {
+    const heap = tree.labelHeap;
+    const n = queryLen + 1;
+    const offset = rowStart * n;
+    const first = tree.nodeEdgeOffset[node];
+    const edgeCount = tree.nodeEdgeOffset[node + 1] - first;
+    const leafSlot = decodeLeafSlot(tree.nodeLeafOrder[node]);
+    const totalCount = packedNodeChildCount(edgeCount, leafSlot >= 0);
+    edge: for (let slot = 0; slot < totalCount; slot++) {
+        const edgeOffset = edgeOffsetAtSlot(slot, leafSlot);
+        if (edgeOffset < 0) {
+            const distance = matrix[offset - 1];
+            if (distance <= maxDistance) {
+                const termIndex = tree.nodeValue[node];
+                yield { termIndex, distance, length: termLength };
+            }
+            continue;
+        }
+        const ei = first + edgeOffset;
+        const labelStart = tree.edgeLabelStart[ei];
+        const labelLen = tree.edgeLabelLength[ei];
+        if (shouldPruneFuzzyEdge(rowStart - 1, labelLen, queryLen, maxDistance)) {
+            continue edge;
+        }
+        let i = rowStart;
+        let thisRowOffset = rowStart * n;
+        for (let pos = 0; pos < labelLen; ++pos, ++i, thisRowOffset += n) {
+            const char = heap.charCodeAt(labelStart + pos);
+            const prevRowOffset = thisRowOffset - n;
+            let minDistance = matrix[thisRowOffset];
+            const jmin = Math.max(0, i - maxDistance - 1);
+            const jmax = Math.min(queryLen, i + maxDistance);
+            for (let j = jmin; j < jmax; ++j) {
+                const different = char === queryCodes[j] ? 0 : 1;
+                const rpl = matrix[prevRowOffset + j] + different;
+                const del = matrix[prevRowOffset + j + 1] + 1;
+                const ins = matrix[thisRowOffset + j] + 1;
+                let dist = rpl;
+                if (del < dist)
+                    dist = del;
+                if (ins < dist)
+                    dist = ins;
+                matrix[thisRowOffset + j + 1] = dist;
+                if (dist < minDistance)
+                    minDistance = dist;
+            }
+            if (minDistance > maxDistance) {
+                continue edge;
+            }
+        }
+        yield* recurse(tree, queryLen, queryCodes, maxDistance, matrix, i, tree.edgeChild[ei], termLength + labelLen);
+    }
+}
+
+function buildLazyTermMetadata(tree) {
+    const termCount = tree.size;
+    const nodeCount = tree.nodeCount;
+    const edgeCount = tree.edgeCount;
+    if (termCount === 0 || nodeCount === 0) {
+        return {
+            leafNodeByTermIndex: new Uint8Array(0),
+            parentNode: new Uint8Array(0),
+            parentEdge: new Uint8Array(0),
+        };
+    }
+    const leafNodeByTermIndex = packedIndexArray(termCount, nodeCount - 1);
+    const parentNode = packedIndexArray(nodeCount, nodeCount - 1);
+    const parentEdge = packedIndexArray(nodeCount, Math.max(edgeCount - 1, 0));
+    let leafCount = 0;
+    for (let node = 0; node < nodeCount; node++) {
+        if (decodeLeafSlot(tree.nodeLeafOrder[node]) >= 0) {
+            leafNodeByTermIndex[tree.nodeValue[node]] = node;
+            leafCount++;
+        }
+        const end = tree.nodeEdgeOffset[node + 1];
+        for (let ei = tree.nodeEdgeOffset[node]; ei < end; ei++) {
+            const child = tree.edgeChild[ei];
+            parentNode[child] = node;
+            parentEdge[child] = ei;
+        }
+    }
+    if (leafCount !== termCount) {
+        throw new Error(`PackedRadixTree: lazy metadata leaf count ${leafCount} !== term count ${termCount}`);
+    }
+    return { leafNodeByTermIndex, parentNode, parentEdge };
+}
+function assertTermIndex(tree, termIndex) {
+    if (termIndex < 0 || termIndex >= tree.size) {
+        throw new RangeError(`PackedRadixTree: term index out of range: ${termIndex}`);
+    }
+}
+/** Reconstruct a single term by climbing parent edges from its leaf to the root. */
+function reconstructTermFromIndex(tree, metadata, termIndex) {
+    assertTermIndex(tree, termIndex);
+    const heap = tree.labelHeap;
+    const { edgeLabelStart, edgeLabelLength } = tree;
+    let result = '';
+    let node = metadata.leafNodeByTermIndex[termIndex];
+    while (node !== 0) {
+        const ei = metadata.parentEdge[node];
+        result = labelSlice(heap, edgeLabelStart[ei], edgeLabelLength[ei]) + result;
+        node = metadata.parentNode[node];
+    }
+    return result;
+}
+/** Term length (UTF-16 code units) without materializing the string. */
+function termLengthFromIndex(tree, metadata, termIndex) {
+    assertTermIndex(tree, termIndex);
+    let length = 0;
+    let node = metadata.leafNodeByTermIndex[termIndex];
+    while (node !== 0) {
+        length += tree.edgeLabelLength[metadata.parentEdge[node]];
+        node = metadata.parentNode[node];
+    }
+    return length;
+}
+
+function labelsMatch(heap, start, len, key, keyOff) {
+    for (let i = 0; i < len; i++) {
+        if (heap.charCodeAt(start + i) !== key.charCodeAt(keyOff + i))
+            return false;
+    }
+    return true;
+}
+function pushEmitFrame(frames, tree, node, prefix) {
+    const first = tree.nodeEdgeOffset[node];
+    const edgeCount = tree.nodeEdgeOffset[node + 1] - first;
+    const leafSlot = decodeLeafSlot(tree.nodeLeafOrder[node]);
+    const totalCount = packedNodeChildCount(edgeCount, leafSlot >= 0);
+    frames.push({ node, slot: totalCount - 1, first, leafSlot, prefix });
+}
+function pushEmitRefFrame(frames, tree, node, length) {
+    const first = tree.nodeEdgeOffset[node];
+    const edgeCount = tree.nodeEdgeOffset[node + 1] - first;
+    const leafSlot = decodeLeafSlot(tree.nodeLeafOrder[node]);
+    const totalCount = packedNodeChildCount(edgeCount, leafSlot >= 0);
+    frames.push({ node, slot: totalCount - 1, first, leafSlot, length });
+}
+class PackedRadixTree {
+    constructor(data) {
+        this.size = data.size;
+        this.nodeCount = data.nodeCount;
+        this.edgeCount = data.edgeCount;
+        this.labelHeap = data.labelHeap;
+        this.nodeEdgeOffset = data.nodeEdgeOffset;
+        this.nodeValue = data.nodeValue;
+        this.nodeLeafOrder = data.nodeLeafOrder;
+        this.edgeLabelStart = data.edgeLabelStart;
+        this.edgeLabelLength = data.edgeLabelLength;
+        this.edgeChild = data.edgeChild;
+    }
+    static fromData(data) {
+        return new PackedRadixTree(data);
+    }
+    findEdge(node, firstChar) {
+        const end = this.nodeEdgeOffset[node + 1];
+        const heap = this.labelHeap;
+        for (let ei = this.nodeEdgeOffset[node]; ei < end; ei++) {
+            if (heap.charCodeAt(this.edgeLabelStart[ei]) === firstChar)
+                return ei;
+        }
+        return -1;
+    }
+    get(term) {
+        const walk = this.walkKey(term, false);
+        if (walk == null || !walk.keyFullyConsumed)
+            return undefined;
+        if (this.nodeLeafOrder[walk.node] === 0)
+            return undefined;
+        return this.nodeValue[walk.node];
+    }
+    *entries() {
+        yield* this.emitSubtree(0, '');
+    }
+    /** @deprecated Internal benchmark/compat wrapper. Prefer `prefixRefs` + `termByIndex`. */
+    *prefixEntries(prefix) {
+        const start = this.resolvePrefixWalk(prefix);
+        if (start == null)
+            return;
+        yield* this.emitSubtree(start.node, start.prefix);
+    }
+    *prefixRefs(prefix) {
+        const start = this.resolvePrefixWalkRef(prefix);
+        if (start == null)
+            return;
+        yield* this.emitSubtreeRefs(start.node, start.prefixLength);
+    }
+    /**
+     * Walk `prefix` to the subtree root; returns accumulated heap label prefix string.
+     * `null` when no terms share the prefix.
+     */
+    resolvePrefixWalk(prefix) {
+        if (prefix.length === 0) {
+            return { node: 0, prefix: '' };
+        }
+        const walk = this.walkKey(prefix, true);
+        if (walk == null)
+            return null;
+        return { node: walk.node, prefix: walk.prefix };
+    }
+    resolvePrefixWalkRef(prefix) {
+        if (prefix.length === 0) {
+            return { node: 0, prefixLength: 0 };
+        }
+        const walk = this.walkKey(prefix, false);
+        if (walk == null)
+            return null;
+        return { node: walk.node, prefixLength: walk.prefixLength };
+    }
+    /**
+     * Follow `key` from the root. Shared by exact lookup and prefix iteration.
+     * Mid-edge stop uses the full edge label in `prefix` (SearchableMap parity).
+     */
+    walkKey(key, accumulatePrefix) {
+        let node = 0;
+        let prefixStr = '';
+        let prefixLength = 0;
+        let pos = 0;
+        const heap = this.labelHeap;
+        const n = key.length;
+        while (pos < n) {
+            const ei = this.findEdge(node, key.charCodeAt(pos));
+            if (ei < 0)
+                return null;
+            const start = this.edgeLabelStart[ei];
+            const len = this.edgeLabelLength[ei];
+            const remaining = n - pos;
+            if (remaining < len) {
+                if (!labelsMatch(heap, start, remaining, key, pos))
+                    return null;
+                if (accumulatePrefix)
+                    prefixStr += labelSlice(heap, start, len);
+                prefixLength += len;
+                return { node: this.edgeChild[ei], prefix: prefixStr, prefixLength, keyFullyConsumed: false };
+            }
+            if (!labelsMatch(heap, start, len, key, pos))
+                return null;
+            if (accumulatePrefix)
+                prefixStr += labelSlice(heap, start, len);
+            prefixLength += len;
+            pos += len;
+            node = this.edgeChild[ei];
+        }
+        return { node, prefix: prefixStr, prefixLength, keyFullyConsumed: true };
+    }
+    /**
+     * Depth-first traversal matching {@link SearchableMap}'s `TreeIterator`, which
+     * visits siblings in reverse Map-insertion order (last key first). The leaf, if
+     * any, sits at `nodeLeafOrder` among the original sibling slots; everything else
+     * is an edge. Exact order matters for prefix iteration and autoSuggest parity.
+     */
+    *emitSubtree(startNode, startPrefix) {
+        const heap = this.labelHeap;
+        const frames = [];
+        pushEmitFrame(frames, this, startNode, startPrefix);
+        while (frames.length) {
+            const frame = frames[frames.length - 1];
+            if (frame.slot < 0) {
+                frames.pop();
+                continue;
+            }
+            const slot = frame.slot--;
+            const edgeOffset = edgeOffsetAtSlot(slot, frame.leafSlot);
+            if (edgeOffset < 0) {
+                yield [frame.prefix, this.nodeValue[frame.node]];
+                continue;
+            }
+            const ei = frame.first + edgeOffset;
+            const start = this.edgeLabelStart[ei];
+            const len = this.edgeLabelLength[ei];
+            const childPrefix = frame.prefix + labelSlice(heap, start, len);
+            pushEmitFrame(frames, this, this.edgeChild[ei], childPrefix);
+        }
+    }
+    *emitSubtreeRefs(startNode, startLength) {
+        const frames = [];
+        pushEmitRefFrame(frames, this, startNode, startLength);
+        while (frames.length) {
+            const frame = frames[frames.length - 1];
+            if (frame.slot < 0) {
+                frames.pop();
+                continue;
+            }
+            const slot = frame.slot--;
+            const edgeOffset = edgeOffsetAtSlot(slot, frame.leafSlot);
+            if (edgeOffset < 0) {
+                yield { termIndex: this.nodeValue[frame.node], length: frame.length };
+                continue;
+            }
+            const ei = frame.first + edgeOffset;
+            const len = this.edgeLabelLength[ei];
+            pushEmitRefFrame(frames, this, this.edgeChild[ei], frame.length + len);
+        }
+    }
+    /** @deprecated Internal benchmark/compat wrapper. Prefer `fuzzyRefs` + `termByIndex`. */
+    fuzzyEntries(term, maxDistance) {
+        return packedRadixFuzzyEntries(this, term, maxDistance);
+    }
+    fuzzyRefs(term, maxDistance) {
+        return packedRadixFuzzyRefs(this, term, maxDistance);
+    }
+    lazyTermMetadata() {
+        if (this._lazyTermMetadata == null) {
+            this._lazyTermMetadata = buildLazyTermMetadata(this);
+        }
+        return this._lazyTermMetadata;
+    }
+    termLengthByIndex(termIndex) {
+        return termLengthFromIndex(this, this.lazyTermMetadata(), termIndex);
+    }
+    termByIndex(termIndex) {
+        return reconstructTermFromIndex(this, this.lazyTermMetadata(), termIndex);
+    }
+    packedByteLength() {
+        return (this.nodeEdgeOffset.byteLength
+            + this.nodeValue.byteLength
+            + this.nodeLeafOrder.byteLength
+            + this.edgeLabelStart.byteLength
+            + this.edgeLabelLength.byteLength
+            + this.edgeChild.byteLength
+            + this.labelHeap.length * 2);
+    }
+    packedNodeCount() {
+        return this.nodeCount;
+    }
+    packedEdgeCount() {
+        return this.edgeCount;
+    }
+}
+
+function fromRadixTree(tree, termCountOrOptions) {
+    if (termCountOrOptions != null && typeof termCountOrOptions === 'object') {
+        const { termCount, mapLeaf, inferTermCountFromLeaves = false } = termCountOrOptions;
+        return packRadixTreeFromRadix(tree, termCount, mapLeaf, inferTermCountFromLeaves);
+    }
+    const termCount = termCountOrOptions;
+    if (termCount == null) {
+        return packRadixTreeFromRadix(tree, 0, leaf => leaf, true);
+    }
+    return packRadixTreeFromRadix(tree, termCount, leaf => leaf, false);
+}
+function packRadixTreeFromRadix(tree, termCount, mapLeaf, inferTermCountFromLeaves) {
+    const nodes = [];
+    let leafCount = 0;
+    function packNode(node) {
+        const nodeId = nodes.length;
+        const scratch = { value: PACKED_NO_VALUE, leafOrder: PACKED_NO_VALUE, edges: [] };
+        nodes.push(scratch);
+        let childOrder = 0;
+        for (const [key, val] of node) {
+            if (key === LEAF) {
+                scratch.value = mapLeaf(val);
+                scratch.leafOrder = childOrder;
+                leafCount++;
+            }
+            else {
+                scratch.edges.push({ label: key, child: packNode(val) });
+            }
+            childOrder++;
+        }
+        return nodeId;
+    }
+    packNode(tree);
+    const size = inferTermCountFromLeaves ? leafCount : termCount;
+    const nodeCount = nodes.length;
+    let edgeCount = 0;
+    let totalLabelLength = 0;
+    let maxLabelLength = 0;
+    let maxNodeValue = 0;
+    let maxLeafOrderEncoded = 0;
+    for (const node of nodes) {
+        edgeCount += node.edges.length;
+        for (const edge of node.edges) {
+            totalLabelLength += edge.label.length;
+            if (edge.label.length > maxLabelLength)
+                maxLabelLength = edge.label.length;
+        }
+        if (node.value !== PACKED_NO_VALUE) {
+            if (node.value > maxNodeValue)
+                maxNodeValue = node.value;
+            if (node.leafOrder + 1 > maxLeafOrderEncoded)
+                maxLeafOrderEncoded = node.leafOrder + 1;
+        }
+    }
+    const nodeEdgeOffset = packedIndexArray(nodeCount + 1, edgeCount);
+    const nodeValue = packedIndexArray(nodeCount, maxNodeValue);
+    const nodeLeafOrder = packedIndexArray(nodeCount, maxLeafOrderEncoded);
+    const edgeLabelStart = packedIndexArray(edgeCount, totalLabelLength);
+    const edgeLabelLength = packedIndexArray(edgeCount, maxLabelLength);
+    const edgeChild = packedIndexArray(edgeCount, Math.max(nodeCount - 1, 0));
+    const labelParts = [];
+    let labelHeapLength = 0;
+    let edgeIndex = 0;
+    for (let nodeId = 0; nodeId < nodeCount; nodeId++) {
+        const node = nodes[nodeId];
+        // nodeLeafOrder: 0 = no leaf, slot + 1 otherwise; nodeValue unused when no leaf.
+        if (node.value !== PACKED_NO_VALUE) {
+            nodeValue[nodeId] = node.value;
+            nodeLeafOrder[nodeId] = node.leafOrder + 1;
+        }
+        nodeEdgeOffset[nodeId] = edgeIndex;
+        for (const edge of node.edges) {
+            if (edge.label.length > MAX_PACKED_EDGE_LABEL_LENGTH) {
+                throw new Error('PackedRadixTree: edge label too long');
+            }
+            const start = labelHeapLength;
+            labelParts.push(edge.label);
+            labelHeapLength += edge.label.length;
+            edgeLabelStart[edgeIndex] = start;
+            edgeLabelLength[edgeIndex] = edge.label.length;
+            edgeChild[edgeIndex] = edge.child;
+            edgeIndex++;
+        }
+    }
+    nodeEdgeOffset[nodeCount] = edgeIndex;
+    const labelHeap = labelParts.join('');
+    return PackedRadixTree.fromData({
+        size,
+        nodeCount,
+        edgeCount,
+        labelHeap,
+        nodeEdgeOffset,
+        nodeValue,
+        nodeLeafOrder,
+        edgeLabelStart,
+        edgeLabelLength,
+        edgeChild,
+    });
+}
+
+function detectIdentityNumericIds(externalIds, nextId) {
+    if (nextId === 0)
+        return true;
+    for (let i = 0; i < nextId; i++) {
+        if (externalIds[i] !== i)
+            return false;
+    }
+    return true;
+}
+function buildLazyMap(externalIds, nextId) {
+    const map = new Map();
+    for (let i = 0; i < nextId; i++) {
+        const id = externalIds[i];
+        if (id !== undefined)
+            map.set(id, i);
+    }
+    return map;
+}
+function createIdToShortIdLookup(externalIds, nextId) {
+    if (detectIdentityNumericIds(externalIds, nextId)) {
+        return {
+            mode: 'identity',
+            mapEntryCount: 0,
+            has(id) {
+                return typeof id === 'number' && Number.isInteger(id) && id >= 0 && id < nextId;
+            },
+            get(id) {
+                if (typeof id === 'number' && Number.isInteger(id) && id >= 0 && id < nextId) {
+                    return id;
+                }
+                return undefined;
+            },
+        };
+    }
+    let map;
+    const ensureMap = () => {
+        if (map == null)
+            map = buildLazyMap(externalIds, nextId);
+        return map;
+    };
+    return {
+        mode: 'lazy-map',
+        get mapEntryCount() {
+            var _a;
+            return (_a = map === null || map === void 0 ? void 0 : map.size) !== null && _a !== void 0 ? _a : 0;
+        },
+        has(id) {
+            return ensureMap().has(id);
+        },
+        get(id) {
+            return ensureMap().get(id);
+        },
+    };
+}
+
+const ID_TAG_EMPTY = 0;
+const ID_TAG_NUMBER = 1;
+const ID_TAG_STRING = 2;
+const ID_TAG_JSON = 3;
+
+// Default import (not `{ crc32 }`): `zlib.crc32` landed in Node 22.2.0 / 20.15.0. A named ESM
+// import would throw at module load on older runtimes; property access is safe and lets
+// `crc32Update` fall back to the pure-JS table below.
+const zlibCrc32 = typeof zlib.crc32 === 'function' ? zlib.crc32 : undefined;
+function invalidFrozenIndex(detail) {
+    return new Error(`Invalid frozen index: ${detail}`);
+}
+function assertBufferLength(buf, min) {
+    if (buf.length < min) {
+        throw invalidFrozenIndex(`buffer too short (${buf.length} < ${min})`);
+    }
+}
+const CRC_TABLE = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let j = 0; j < 8; j++) {
+        c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+    }
+    CRC_TABLE[i] = c;
+}
+function crc32BufferFallback(buf, start, end, seed = 0) {
+    let crc = (seed ^ 0xffffffff) >>> 0;
+    for (let i = start; i < end; i++) {
+        crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ buf[i]) & 0xff];
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/** Incremental CRC-32 IEEE update; pass the previous return value as `seed`. */
+function crc32Update(seed, buf, start = 0, end = buf.length) {
+    if (typeof zlibCrc32 === 'function') {
+        const slice = start === 0 && end === buf.length ? buf : buf.subarray(start, end);
+        return zlibCrc32(slice, seed) >>> 0;
+    }
+    return crc32BufferFallback(buf, start, end, seed);
+}
+/** CRC-32 IEEE (zlib polynomial); uses `zlib.crc32` when available. */
+function crc32Buffer(buf, start = 0, end = buf.length) {
+    return crc32Update(0, buf, start, end);
+}
+function readUint32Array(buf, offset, byteLength) {
+    if (byteLength === 0)
+        return new Uint32Array(0);
+    if (byteLength % 4 !== 0) {
+        throw invalidFrozenIndex('uint32 section length not aligned');
+    }
+    if (offset + byteLength > buf.length) {
+        throw invalidFrozenIndex('uint32 section read past buffer end');
+    }
+    if (offset % 4 === 0) {
+        return new Uint32Array(buf.buffer, buf.byteOffset + offset, byteLength / 4);
+    }
+    const out = new Uint32Array(byteLength / 4);
+    for (let i = 0; i < out.length; i++)
+        out[i] = buf.readUInt32LE(offset + i * 4);
+    return out;
+}
+function readUint16Array(buf, offset, byteLength) {
+    if (byteLength === 0)
+        return new Uint16Array(0);
+    if (byteLength % 2 !== 0) {
+        throw invalidFrozenIndex('uint16 section length not aligned');
+    }
+    if (offset + byteLength > buf.length) {
+        throw invalidFrozenIndex('uint16 section read past buffer end');
+    }
+    {
+        return new Uint16Array(buf.buffer, buf.byteOffset + offset, byteLength / 2);
+    }
+}
+function readUint8Array(buf, offset, byteLength) {
+    if (byteLength === 0)
+        return new Uint8Array(0);
+    if (offset + byteLength > buf.length) {
+        throw invalidFrozenIndex('uint8 section read past buffer end');
+    }
+    return new Uint8Array(buf.buffer, buf.byteOffset + offset, byteLength);
+}
+function readFloat32Array(buf, offset, byteLength) {
+    if (byteLength === 0)
+        return new Float32Array(0);
+    if (byteLength % 4 !== 0) {
+        throw invalidFrozenIndex('float32 section length not aligned');
+    }
+    if (offset + byteLength > buf.length) {
+        throw invalidFrozenIndex('float32 section read past buffer end');
+    }
+    {
+        return new Float32Array(buf.buffer, buf.byteOffset + offset, byteLength / 4);
+    }
+}
+function bufferFromView(view) {
+    return Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+}
+function readFieldIdArray(buf, offset, byteLength, width) {
+    if (width === 8)
+        return readUint8Array(buf, offset, byteLength);
+    return readUint16Array(buf, offset, byteLength);
+}
+function writeLengthPrefixedUtf8(chunks, str) {
+    const body = Buffer.from(str, 'utf8');
+    const header = Buffer.alloc(4);
+    header.writeUInt32LE(body.length, 0);
+    chunks.push(header, body);
+}
+function readLengthPrefixedUtf8(buf, offset) {
+    if (offset + 4 > buf.length) {
+        throw invalidFrozenIndex('length-prefixed string header truncated');
+    }
+    const len = buf.readUInt32LE(offset);
+    const start = offset + 4;
+    const end = start + len;
+    if (end > buf.length) {
+        throw invalidFrozenIndex('length-prefixed string body out of bounds');
+    }
+    return { value: buf.toString('utf8', start, end), next: end };
+}
+function writeExternalId(chunks, id) {
+    if (id === undefined) {
+        chunks.push(Buffer.from([ID_TAG_EMPTY]));
+        return;
+    }
+    if (typeof id === 'number' && Number.isFinite(id)) {
+        const header = Buffer.alloc(1 + 8);
+        header.writeUInt8(ID_TAG_NUMBER, 0);
+        header.writeDoubleLE(id, 1);
+        chunks.push(header);
+        return;
+    }
+    if (typeof id === 'string') {
+        const tag = Buffer.from([ID_TAG_STRING]);
+        chunks.push(tag);
+        writeLengthPrefixedUtf8(chunks, id);
+        return;
+    }
+    const json = JSON.stringify(id);
+    const tag = Buffer.from([ID_TAG_JSON]);
+    chunks.push(tag);
+    writeLengthPrefixedUtf8(chunks, json);
+}
+function readExternalId(buf, offset) {
+    if (offset >= buf.length) {
+        throw invalidFrozenIndex('external id tag truncated');
+    }
+    const tag = buf.readUInt8(offset);
+    if (tag === ID_TAG_EMPTY) {
+        return { value: undefined, next: offset + 1 };
+    }
+    if (tag === ID_TAG_NUMBER) {
+        if (offset + 9 > buf.length) {
+            throw invalidFrozenIndex('external id number truncated');
+        }
+        return { value: buf.readDoubleLE(offset + 1), next: offset + 9 };
+    }
+    if (tag === ID_TAG_STRING) {
+        const { value, next } = readLengthPrefixedUtf8(buf, offset + 1);
+        return { value, next };
+    }
+    if (tag === ID_TAG_JSON) {
+        const { value, next } = readLengthPrefixedUtf8(buf, offset + 1);
+        return { value: JSON.parse(value), next };
+    }
+    throw invalidFrozenIndex(`unknown external id tag ${tag}`);
+}
+
+/** MSv5 unified frozen snapshot (columnar tree, single payload zstd stream). */
+/** Postings / field-length flags (low 16 bits of global flags at offset 6). */
+const FLAG_DOC_ID_16 = 1;
+const FLAG_SPARSE_LAYOUT = 2;
+const FLAG_FIELD_ID_16 = 4;
+const FLAG_FL_U8 = 8;
+const FLAG_FL_U16 = 16;
+const FLAG_FREQ_U16 = 32;
+const CODEC_RAW = 0;
+/** Zstandard (`node:zlib`) on the whole payload. */
+const CODEC_ZSTD = 3;
+/** Single concatenated payload, one zstd stream (or raw). */
+const MSV5_FORMAT_REV_PAYLOAD = 1;
+/** Do not compress payloads smaller than this (bytes). */
+const MSV5_MIN_COMPRESS_BYTES = 64;
+/** Fixed zstd compression level for the whole payload. */
+const MSV5_ZSTD_LEVEL = 9;
+const MSV5_SECTION_COUNT = 12;
+/** Per-section catalogue entry: fileOffset(4) + uncompressedLength(4) + crc32(4) + reserved(8). */
+const MSV5_SECTION_ENTRY_BYTES = 20;
+/** magic(4) + version(2) + indexFlags(2) + payloadMeta(4) + formatRev(2) + sectionCount(4) */
+const MSV5_HEADER_PREFIX_SIZE = 32;
+const MSV5_HEADER_SIZE = MSV5_HEADER_PREFIX_SIZE + MSV5_SECTION_COUNT * MSV5_SECTION_ENTRY_BYTES;
+const MSV5_PAYLOAD_CODEC_OFFSET = 8;
+const MSV5_ZSTD_LEVEL_OFFSET = 9;
+const MSV5_FORMAT_REV_OFFSET = 10;
+const MSV5_SECTION_COUNT_OFFSET = 12;
+/** compressedOffset, compressedLength, uncompressedLength, payloadCrc32 (each u32). */
+const MSV5_PAYLOAD_COMPRESSED_OFFSET = 16;
+const MSV5_PAYLOAD_COMPRESSED_LENGTH_OFFSET = 20;
+const MSV5_PAYLOAD_UNCOMPRESSED_LENGTH_OFFSET = 24;
+const MSV5_PAYLOAD_CRC_OFFSET = 28;
+const MSV5_SECTION_DIR_OFFSET = MSV5_HEADER_PREFIX_SIZE;
+/** Tree column order for columnWidthFlags bit pairs (2 bits each). */
+const MSV5_TREE_COLUMN_COUNT = 6;
+
+function maxInArrayLike(data, length) {
+    var _a;
+    const len = length !== null && length !== void 0 ? length : data.length;
+    let max = 0;
+    for (let i = 0; i < len; i++) {
+        const v = (_a = data[i]) !== null && _a !== void 0 ? _a : 0;
+        if (v > max)
+            max = v;
+    }
+    return max;
+}
+function materializeFieldLengthMatrix(data, length) {
+    var _a;
+    const len = length !== null && length !== void 0 ? length : data.length;
+    const matrix = packedIndexArray(len, maxInArrayLike(data, len));
+    for (let i = 0; i < len; i++) {
+        matrix[i] = (_a = data[i]) !== null && _a !== void 0 ? _a : 0;
+    }
+    return matrix;
+}
+/**
+ * Wire encoding uses adaptive width ({@link fieldLengthMatrixWireFlags});
+ * {@link readFieldLengthMatrixSection} restores u8/u16/u32.
+ * {@link fieldLengthMatrixForWire} widens in-memory u8/u16 matrices to Uint32 for the encoder.
+ */
+function fieldLengthMatrixForWire(matrix) {
+    if (matrix instanceof Uint32Array)
+        return matrix;
+    const out = new Uint32Array(matrix.length);
+    for (let i = 0; i < matrix.length; i++)
+        out[i] = matrix[i];
+    return out;
+}
+/** Global wire flags for {@link FieldLengthArray} width. */
+function fieldLengthMatrixWireFlags(matrix) {
+    if (matrix instanceof Uint8Array)
+        return FLAG_FL_U8;
+    if (matrix instanceof Uint16Array)
+        return FLAG_FL_U16;
+    return 0;
+}
+function buildFieldLengthMatrixSection(matrix) {
+    return Buffer.from(matrix.buffer, matrix.byteOffset, matrix.byteLength);
+}
+function readFieldLengthMatrixSection(buf, flags, cellCount) {
+    if ((flags & FLAG_FL_U8) !== 0) {
+        if (buf.length !== cellCount) {
+            throw invalidFrozenIndex('fieldLengthMatrix u8 size mismatch');
+        }
+        return buf.length === 0
+            ? new Uint8Array(0)
+            : new Uint8Array(buf.buffer, buf.byteOffset, cellCount);
+    }
+    if ((flags & FLAG_FL_U16) !== 0) {
+        if (buf.length !== cellCount * 2) {
+            throw invalidFrozenIndex('fieldLengthMatrix u16 size mismatch');
+        }
+        return cellCount === 0
+            ? new Uint16Array(0)
+            : new Uint16Array(buf.buffer, buf.byteOffset, cellCount);
+    }
+    if (buf.length !== cellCount * 4) {
+        throw invalidFrozenIndex('fieldLengthMatrix u32 size mismatch');
+    }
+    return cellCount === 0
+        ? new Uint32Array(0)
+        : new Uint32Array(buf.buffer, buf.byteOffset, cellCount);
+}
+
+const DISCARDED_DOC_ID = 0xffffffff;
+function postingFreqValue(freq, clampFrequencies) {
+    return clampFrequencies ? clampFreq(freq) : freq;
+}
+function materializeFlatPostings(params) {
+    const { fieldCount, termCount, forEachPosting, remapDocId, clampFrequencies } = params;
+    const slotCount = termCount * fieldCount;
+    const postingsOffsets = new Uint32Array(slotCount);
+    const postingsLengths = new Uint32Array(slotCount);
+    let totalPostings = 0;
+    let maxFreq = 0;
+    for (let ti = 0; ti < termCount; ti++) {
+        for (let f = 0; f < fieldCount; f++) {
+            forEachPosting(ti, f, (rawDocId, freq) => {
+                const docId = remapDocId != null ? remapDocId(rawDocId) : rawDocId;
+                if (docId === DISCARDED_DOC_ID)
+                    return;
+                totalPostings++;
+                const v = postingFreqValue(freq, clampFrequencies);
+                if (v > maxFreq)
+                    maxFreq = v;
+            });
+        }
+    }
+    const useUint16 = params.nextId != null && params.nextId <= 65535;
+    const allDocIds = useUint16
+        ? new Uint16Array(totalPostings)
+        : new Uint32Array(totalPostings);
+    const allFreqs = allocateFreqs(totalPostings, maxFreq);
+    // Slots are visited in ascending fieldId (0..fieldCount-1) per term. Sparse layouts
+    // rely on this ordering so field ids per term stay sorted for binary lookup.
+    let write = 0;
+    for (let ti = 0; ti < termCount; ti++) {
+        const base = ti * fieldCount;
+        for (let f = 0; f < fieldCount; f++) {
+            const offset = write;
+            let count = 0;
+            forEachPosting(ti, f, (rawDocId, freq) => {
+                const docId = remapDocId != null ? remapDocId(rawDocId) : rawDocId;
+                if (docId === DISCARDED_DOC_ID)
+                    return;
+                if (useUint16) {
+                    allDocIds[write] = docId;
+                }
+                else {
+                    allDocIds[write] = docId;
+                }
+                allFreqs[write] = postingFreqValue(freq, clampFrequencies);
+                write++;
+                count++;
+            });
+            postingsOffsets[base + f] = offset;
+            postingsLengths[base + f] = count;
+        }
+    }
+    return {
+        postingsOffsets,
+        postingsLengths,
+        allDocIds,
+        allFreqs,
+    };
+}
+
+function readFieldId(fieldIds, index) {
+    return fieldIds[index];
+}
+function choosePostingsLayout(fieldCount) {
+    return fieldCount === 1 ? 'dense' : 'sparse';
+}
+function chooseSparseFieldIdWidth(fieldCount) {
+    return fieldCount > 255 ? 16 : 8;
+}
+function materializeFrozenPostings(params) {
+    const { fieldCount, termCount, nextId } = params;
+    const layout = choosePostingsLayout(fieldCount);
+    const docIdWidth = nextId <= 65535 ? 16 : 32;
+    if (layout === 'dense') {
+        const flat = materializeFlatPostings({ ...params, nextId });
+        return {
+            fieldCount,
+            termCount,
+            nextId,
+            layout,
+            docIdWidth,
+            sparseFieldIdWidth: null,
+            allDocIds: flat.allDocIds,
+            allFreqs: flat.allFreqs,
+            denseOffsets: flat.postingsOffsets,
+            denseLengths: flat.postingsLengths,
+            sparseTermStarts: null,
+            sparseFieldIds: null,
+            sparseOffsets: null,
+            sparseLengths: null,
+        };
+    }
+    const sparseFieldIdWidth = chooseSparseFieldIdWidth(fieldCount);
+    const sparseFieldIdsScratch = [];
+    const sparseOffsets = [];
+    const sparseLengths = [];
+    const termStarts = new Array(termCount + 1).fill(0);
+    const { forEachPosting, remapDocId, clampFrequencies } = params;
+    // Non-empty slots per term are emitted with fieldId in ascending order (f loops 0..fieldCount-1).
+    let totalPostings = 0;
+    let maxFreq = 0;
+    for (let ti = 0; ti < termCount; ti++) {
+        termStarts[ti] = sparseFieldIdsScratch.length;
+        for (let f = 0; f < fieldCount; f++) {
+            let count = 0;
+            forEachPosting(ti, f, (rawDocId, freq) => {
+                const docId = remapDocId != null ? remapDocId(rawDocId) : rawDocId;
+                if (docId === DISCARDED_DOC_ID)
+                    return;
+                count++;
+                const v = postingFreqValue(freq, clampFrequencies);
+                if (v > maxFreq)
+                    maxFreq = v;
+            });
+            if (count === 0)
+                continue;
+            sparseFieldIdsScratch.push(f);
+            sparseOffsets.push(totalPostings);
+            sparseLengths.push(count);
+            totalPostings += count;
+        }
+        termStarts[ti + 1] = sparseFieldIdsScratch.length;
+    }
+    const allDocIds = docIdWidth === 16
+        ? new Uint16Array(totalPostings)
+        : new Uint32Array(totalPostings);
+    const allFreqs = allocateFreqs(totalPostings, maxFreq);
+    const sparseFieldIds = sparseFieldIdWidth === 16
+        ? new Uint16Array(sparseFieldIdsScratch)
+        : new Uint8Array(sparseFieldIdsScratch);
+    let write = 0;
+    for (let ti = 0; ti < termCount; ti++) {
+        const start = termStarts[ti];
+        const end = termStarts[ti + 1];
+        for (let s = start; s < end; s++) {
+            const f = readFieldId(sparseFieldIds, s);
+            forEachPosting(ti, f, (rawDocId, freq) => {
+                const docId = remapDocId != null ? remapDocId(rawDocId) : rawDocId;
+                if (docId === DISCARDED_DOC_ID)
+                    return;
+                if (docIdWidth === 16) {
+                    allDocIds[write] = docId;
+                }
+                else {
+                    allDocIds[write] = docId;
+                }
+                allFreqs[write] = postingFreqValue(freq, clampFrequencies);
+                write++;
+            });
+        }
+    }
+    return {
+        fieldCount,
+        termCount,
+        nextId,
+        layout,
+        docIdWidth,
+        sparseFieldIdWidth,
+        allDocIds,
+        allFreqs,
+        denseOffsets: null,
+        denseLengths: null,
+        sparseTermStarts: new Uint32Array(termStarts),
+        sparseFieldIds,
+        sparseOffsets: new Uint32Array(sparseOffsets),
+        sparseLengths: new Uint32Array(sparseLengths),
+    };
+}
+/** One-pass materialize from {@link FrozenIndexBuilder} scratch (counts known upfront). */
+function materializeFrozenPostingsFromBuilder(state, nextId) {
+    var _a;
+    const { fieldCount, termCount, postingsDocIds, postingsFreqs, totalPostings, maxFreq } = state;
+    const layout = choosePostingsLayout(fieldCount);
+    const docIdWidth = nextId <= 65535 ? 16 : 32;
+    const allDocIds = docIdWidth === 16
+        ? new Uint16Array(totalPostings)
+        : new Uint32Array(totalPostings);
+    const allFreqs = allocateFreqs(totalPostings, maxFreq);
+    if (layout === 'dense') {
+        const slotCount = termCount * fieldCount;
+        const denseOffsets = new Uint32Array(slotCount);
+        const denseLengths = new Uint32Array(slotCount);
+        let write = 0;
+        for (let ti = 0; ti < termCount; ti++) {
+            const base = ti * fieldCount;
+            for (let f = 0; f < fieldCount; f++) {
+                const slot = base + f;
+                const docIds = postingsDocIds[slot];
+                const freqs = postingsFreqs[slot];
+                const len = (_a = docIds === null || docIds === void 0 ? void 0 : docIds.length) !== null && _a !== void 0 ? _a : 0;
+                denseOffsets[slot] = write;
+                denseLengths[slot] = len;
+                for (let i = 0; i < len; i++) {
+                    const docId = docIds[i];
+                    if (docIdWidth === 16) {
+                        allDocIds[write] = docId;
+                    }
+                    else {
+                        allDocIds[write] = docId;
+                    }
+                    allFreqs[write] = freqs[i];
+                    write++;
+                }
+            }
+        }
+        return {
+            fieldCount,
+            termCount,
+            nextId,
+            layout,
+            docIdWidth,
+            sparseFieldIdWidth: null,
+            allDocIds,
+            allFreqs,
+            denseOffsets,
+            denseLengths,
+            sparseTermStarts: null,
+            sparseFieldIds: null,
+            sparseOffsets: null,
+            sparseLengths: null,
+        };
+    }
+    const sparseFieldIdWidth = chooseSparseFieldIdWidth(fieldCount);
+    const sparseFieldIdsScratch = [];
+    const sparseOffsets = [];
+    const sparseLengths = [];
+    const termStarts = new Array(termCount + 1).fill(0);
+    let write = 0;
+    for (let ti = 0; ti < termCount; ti++) {
+        termStarts[ti] = sparseFieldIdsScratch.length;
+        for (let f = 0; f < fieldCount; f++) {
+            const slot = ti * fieldCount + f;
+            const docIds = postingsDocIds[slot];
+            if (docIds == null || docIds.length === 0)
+                continue;
+            const freqs = postingsFreqs[slot];
+            sparseFieldIdsScratch.push(f);
+            sparseOffsets.push(write);
+            sparseLengths.push(docIds.length);
+            for (let i = 0; i < docIds.length; i++) {
+                const docId = docIds[i];
+                if (docIdWidth === 16) {
+                    allDocIds[write] = docId;
+                }
+                else {
+                    allDocIds[write] = docId;
+                }
+                allFreqs[write] = freqs[i];
+                write++;
+            }
+        }
+        termStarts[ti + 1] = sparseFieldIdsScratch.length;
+    }
+    const sparseFieldIds = sparseFieldIdWidth === 16
+        ? new Uint16Array(sparseFieldIdsScratch)
+        : new Uint8Array(sparseFieldIdsScratch);
+    return {
+        fieldCount,
+        termCount,
+        nextId,
+        layout,
+        docIdWidth,
+        sparseFieldIdWidth,
+        allDocIds,
+        allFreqs,
+        denseOffsets: null,
+        denseLengths: null,
+        sparseTermStarts: new Uint32Array(termStarts),
+        sparseFieldIds,
+        sparseOffsets: new Uint32Array(sparseOffsets),
+        sparseLengths: new Uint32Array(sparseLengths),
+    };
+}
+function postingsTypedBytes(layout) {
+    const allDocIdsBytes = layout.allDocIds.byteLength;
+    const allFreqsBytes = layout.allFreqs.byteLength;
+    if (layout.layout === 'dense') {
+        const offsetsBytes = layout.denseOffsets.byteLength;
+        const lengthsBytes = layout.denseLengths.byteLength;
+        return {
+            allDocIdsBytes,
+            allFreqsBytes,
+            offsetsBytes,
+            lengthsBytes,
+            totalTypedBytes: allDocIdsBytes + allFreqsBytes + offsetsBytes + lengthsBytes,
+            slotCount: layout.termCount * layout.fieldCount,
+        };
+    }
+    const offsetsBytes = layout.sparseOffsets.byteLength + layout.sparseTermStarts.byteLength;
+    const lengthsBytes = layout.sparseLengths.byteLength + layout.sparseFieldIds.byteLength;
+    const slotCount = layout.sparseFieldIds.length;
+    return {
+        allDocIdsBytes,
+        allFreqsBytes,
+        offsetsBytes,
+        lengthsBytes,
+        totalTypedBytes: allDocIdsBytes + allFreqsBytes + offsetsBytes + lengthsBytes,
+        slotCount,
+    };
+}
+function validateFrozenPostingsLayout(layout, documentCount, nextId, fail = detail => { throw new Error(detail); }) {
+    if (layout.fieldCount <= 0)
+        fail('fieldCount must be positive');
+    if (layout.nextId !== nextId)
+        fail('nextId mismatch');
+    if (layout.termCount < 0)
+        fail('termCount out of range');
+    if (layout.allDocIds.length !== layout.allFreqs.length) {
+        fail('allDocIds and allFreqs length mismatch');
+    }
+    if (layout.layout === 'dense') {
+        if (layout.sparseFieldIdWidth != null) {
+            fail('dense layout must not have sparseFieldIdWidth');
+        }
+        const slotCount = layout.termCount * layout.fieldCount;
+        if (layout.denseOffsets.length !== slotCount || layout.denseLengths.length !== slotCount) {
+            fail('dense postings slot count mismatch');
+        }
+        for (let slot = 0; slot < slotCount; slot++) {
+            const off = layout.denseOffsets[slot];
+            const len = layout.denseLengths[slot];
+            if (off + len > layout.allDocIds.length) {
+                fail(`posting slot ${slot} exceeds allDocIds bounds`);
+            }
+            for (let i = 0; i < len; i++) {
+                const docId = readDocId(layout.allDocIds, off + i);
+                if (docId >= nextId)
+                    fail(`posting docId ${docId} >= nextId ${nextId}`);
+            }
+        }
+    }
+    else {
+        const expectedFieldIdWidth = chooseSparseFieldIdWidth(layout.fieldCount);
+        if (layout.sparseFieldIdWidth !== expectedFieldIdWidth) {
+            fail('sparseFieldIdWidth mismatch with fieldCount');
+        }
+        const starts = layout.sparseTermStarts;
+        if (starts.length !== layout.termCount + 1)
+            fail('sparseTermStarts length mismatch');
+        const slotCount = layout.sparseFieldIds.length;
+        if (layout.sparseOffsets.length !== slotCount || layout.sparseLengths.length !== slotCount) {
+            fail('sparse slot count mismatch');
+        }
+        for (let slot = 0; slot < slotCount; slot++) {
+            const fieldId = readFieldId(layout.sparseFieldIds, slot);
+            if (fieldId >= layout.fieldCount) {
+                fail(`sparse fieldId ${fieldId} >= fieldCount ${layout.fieldCount}`);
+            }
+            const off = layout.sparseOffsets[slot];
+            const len = layout.sparseLengths[slot];
+            if (off + len > layout.allDocIds.length) {
+                fail(`sparse slot ${slot} exceeds allDocIds bounds`);
+            }
+            for (let i = 0; i < len; i++) {
+                const docId = readDocId(layout.allDocIds, off + i);
+                if (docId >= nextId)
+                    fail(`posting docId ${docId} >= nextId ${nextId}`);
+            }
+        }
+    }
+    if (documentCount < 0 || documentCount > nextId) {
+        fail('documentCount inconsistent with nextId');
+    }
+}
+/**
+ * Locate the slot for `fieldId` within a term's range.
+ *
+ * `sparseFieldIds[start..end)` is sorted ascending (see materializeFrozenPostings),
+ * and the range is short (at most `fieldCount`, usually 1-3 fields per term). A linear
+ * scan with early exit beats binary search at this size: sequential access, predictable
+ * branches, no per-step division. The sorted invariant only powers the early break.
+ */
+function findSparseSlotByFieldId(fieldIds, start, end, fieldId) {
+    for (let i = start; i < end; i++) {
+        const fid = readFieldId(fieldIds, i);
+        if (fid === fieldId)
+            return i;
+        if (fid > fieldId)
+            break;
+    }
+    return -1;
+}
+/** Resolve one (termIndex, fieldId) posting run in flat buffers; shared by flyweight and docId collect. */
+function frozenPostingSlice(layout, termIndex, fieldId) {
+    if (layout.layout === 'dense') {
+        const base = termIndex * layout.fieldCount + fieldId;
+        const len = layout.denseLengths[base];
+        if (len === 0)
+            return undefined;
+        return { offset: layout.denseOffsets[base], length: len };
+    }
+    const start = layout.sparseTermStarts[termIndex];
+    const end = layout.sparseTermStarts[termIndex + 1];
+    const slot = findSparseSlotByFieldId(layout.sparseFieldIds, start, end, fieldId);
+    if (slot < 0)
+        return undefined;
+    const len = layout.sparseLengths[slot];
+    if (len === 0)
+        return undefined;
+    return { offset: layout.sparseOffsets[slot], length: len };
+}
+/**
+ * One flyweight wrapper for the lifetime of a frozen index. Call {@link bind} before each
+ * `get`; the returned object is always the same instance (valid until the next `bind`).
+ */
+function createFrozenFieldTermFlyweight(layout) {
+    let termIndex = -1;
+    const { allDocIds, allFreqs } = layout;
+    const segment = new SegmentPostingList(allDocIds, allFreqs, 0, 0);
+    const flyweight = {
+        bind(ti) {
+            termIndex = ti;
+            return flyweight;
+        },
+        get(fieldId) {
+            const slice = frozenPostingSlice(layout, termIndex, fieldId);
+            if (slice == null)
+                return undefined;
+            return segment.rebind(slice.offset, slice.length);
+        },
+    };
+    return flyweight;
+}
+function collectDocIdsFromFrozenSegment(allDocIds, offset, length, context, docIds, allowedDocs) {
+    for (let i = 0; i < length; i++) {
+        const docId = readDocId(allDocIds, offset + i);
+        if (context.isDocActive != null && !context.isDocActive(docId))
+            continue;
+        if (allowedDocs != null && !allowedDocs.has(docId))
+            continue;
+        docIds.add(docId);
+    }
+}
+/** Collect docIds from flat postings without {@link FieldTermDataLike} wrappers. */
+function collectDocIdsFromFrozenLayout(layout, termIndex, fieldBoosts, context, docIds, allowedDocs) {
+    const { fieldIds } = context;
+    for (const field of fieldBoosts.names) {
+        const slice = frozenPostingSlice(layout, termIndex, fieldIds[field]);
+        if (slice == null)
+            continue;
+        collectDocIdsFromFrozenSegment(layout.allDocIds, slice.offset, slice.length, context, docIds, allowedDocs);
+    }
+}
+
+/** Unicode space, newline, or punctuation — used by the default tokenizer */
+const SPACE_OR_PUNCTUATION = /[\n\r\p{Z}\p{P}]+/u;
+const defaultSearchOptions = {
+    combineWith: OR,
+    prefix: false,
+    fuzzy: false,
+    maxFuzzy: 6,
+    boost: {},
+    weights: { fuzzy: 0.45, prefix: 0.375 },
+    bm25: defaultBM25params,
+};
+const defaultAutoSuggestOptions = {
+    combineWith: AND,
+    prefix: (term, i, terms) => i === terms.length - 1,
+};
+/** Option defaults applied by {@link FrozenMiniSearch.loadBinarySync} before caller overrides */
+const defaultFrozenLoadOptions = {
+    idField: 'id',
+    extractField: (document, fieldName) => document[fieldName],
+    stringifyField: (fieldValue) => fieldValue.toString(),
+    tokenize: (text) => text.split(SPACE_OR_PUNCTUATION),
+    processTerm: (term) => term.toLowerCase(),
+    storeFields: [],
+    logger: () => { },
+    autoVacuum: false,
+};
+
+function resolveIndexingOptions(options) {
+    if ((options === null || options === void 0 ? void 0 : options.fields) == null) {
+        throw new Error('MiniSearch: option "fields" must be provided');
+    }
+    return {
+        ...defaultFrozenLoadOptions,
+        ...options,
+        searchOptions: { ...defaultSearchOptions, ...(options.searchOptions || {}) },
+        autoSuggestOptions: { ...defaultAutoSuggestOptions, ...(options.autoSuggestOptions || {}) },
+    };
+}
+function buildFieldIds(fields) {
+    const fieldIds = {};
+    for (let i = 0; i < fields.length; i++) {
+        fieldIds[fields[i]] = i;
+    }
+    return fieldIds;
+}
+/** Token frequencies for one document field (after processTerm). */
+function collectFieldTermFreqs(tokens, fieldName, processTerm) {
+    const localFreqs = new Map();
+    for (const term of tokens) {
+        const processedTerm = processTerm(term, fieldName);
+        if (Array.isArray(processedTerm)) {
+            for (const t of processedTerm) {
+                localFreqs.set(t, (localFreqs.get(t) || 0) + 1);
+            }
+        }
+        else if (processedTerm) {
+            localFreqs.set(processedTerm, (localFreqs.get(processedTerm) || 0) + 1);
+        }
+    }
+    return localFreqs;
+}
+/** Same running average as {@link MiniSearch} private addFieldLength. */
+function updateAvgFieldLength(avgFieldLength, fieldId, count, length) {
+    const averageFieldLength = avgFieldLength[fieldId] || 0;
+    const totalFieldLength = (averageFieldLength * count) + length;
+    avgFieldLength[fieldId] = totalFieldLength / (count + 1);
+}
+function saveStoredFieldsForDocument(storeFields, extractField, document) {
+    if (storeFields.length === 0)
+        return undefined;
+    const documentFields = {};
+    for (const fieldName of storeFields) {
+        const fieldValue = extractField(document, fieldName);
+        if (fieldValue !== undefined)
+            documentFields[fieldName] = fieldValue;
+    }
+    return documentFields;
+}
+
+const SUPPORTED_SERIALIZATION_VERSIONS = new Set([1, 2]);
+function parseIndexEntry(entry, serializationVersion) {
+    if (serializationVersion === 1 && entry != null && typeof entry === 'object' && 'ds' in entry) {
+        return entry.ds;
+    }
+    return entry;
+}
+function assertFieldsMatchSnapshot$1(optionsFields, snapFieldIds) {
+    const snapNames = Object.keys(snapFieldIds).sort();
+    const optNames = [...optionsFields].sort();
+    if (snapNames.length !== optNames.length || snapNames.some((name, i) => name !== optNames[i])) {
+        throw new Error(`FrozenMiniSearch: option "fields" must match the indexed fields exactly (expected: ${snapNames.join(', ')})`);
+    }
+}
+function buildSearchableMapFromSnapshot(snapshot) {
+    const index = new SearchableMap();
+    const { index: entries, serializationVersion } = snapshot;
+    for (const [term, data] of entries) {
+        const dataMap = new Map();
+        for (const fieldId of Object.keys(data)) {
+            const raw = data[fieldId];
+            const indexEntry = parseIndexEntry(raw, serializationVersion);
+            const freqs = new Map();
+            for (const [docId, freq] of Object.entries(indexEntry)) {
+                freqs.set(parseInt(docId, 10), freq);
+            }
+            dataMap.set(parseInt(fieldId, 10), freqs);
+        }
+        index.set(term, dataMap);
+    }
+    return index;
+}
+function buildFlatPostingsFromSearchableMap(searchableMap, fieldCount, nextId, shortIdRemap) {
+    const fieldIndexByTermIndex = [];
+    const packedIndex = fromRadixTree(searchableMap.radixTree, {
+        termCount: 0,
+        mapLeaf: (leaf) => {
+            const ti = fieldIndexByTermIndex.length;
+            fieldIndexByTermIndex[ti] = leaf;
+            return ti;
+        },
+        inferTermCountFromLeaves: true,
+    });
+    const termCount = packedIndex.size;
+    const remapDocId = shortIdRemap != null
+        ? (docId) => shortIdRemap[docId]
+        : undefined;
+    const postings = materializeFrozenPostings({
+        fieldCount,
+        termCount,
+        nextId,
+        clampFrequencies: true,
+        remapDocId,
+        forEachPosting(ti, f, emit) {
+            var _a;
+            const freqs = (_a = fieldIndexByTermIndex[ti]) === null || _a === void 0 ? void 0 : _a.get(f);
+            if (freqs == null)
+                return;
+            for (const [shortId, freq] of freqs) {
+                emit(shortId, freq);
+            }
+        },
+    });
+    return { termCount, index: packedIndex, postings };
+}
+/** Build frozen assemble params from a lucaong MiniSearch JSON snapshot. */
+function buildFrozenAssembleParamsFromMiniSearchSnapshot(snapshot, options) {
+    var _a, _b, _c;
+    if (!SUPPORTED_SERIALIZATION_VERSIONS.has(snapshot.serializationVersion)) {
+        throw new Error(`FrozenMiniSearch: unsupported MiniSearch serializationVersion ${snapshot.serializationVersion}`);
+    }
+    const snapshotFieldNames = Object.keys(snapshot.fieldIds);
+    const fields = ((_a = options.fields) === null || _a === void 0 ? void 0 : _a.length) ? options.fields : snapshotFieldNames;
+    if ((_b = options.fields) === null || _b === void 0 ? void 0 : _b.length) {
+        assertFieldsMatchSnapshot$1(fields, snapshot.fieldIds);
+    }
+    const opts = resolveIndexingOptions({ ...options, fields });
+    const fieldCount = opts.fields.length;
+    const { documentCount, nextId } = snapshot;
+    const useDense = documentCount < nextId;
+    let shortIdRemap = null;
+    const resolvedNextId = useDense ? documentCount : nextId;
+    const externalIds = new Array(resolvedNextId);
+    const storedFields = new Array(externalIds.length);
+    if (useDense) {
+        shortIdRemap = new Uint32Array(nextId);
+        shortIdRemap.fill(DISCARDED_DOC_ID);
+        let dense = 0;
+        const sortedShortIds = Object.keys(snapshot.documentIds)
+            .map(s => parseInt(s, 10))
+            .sort((a, b) => a - b);
+        for (const shortId of sortedShortIds) {
+            const shortIdStr = String(shortId);
+            shortIdRemap[shortId] = dense;
+            externalIds[dense] = snapshot.documentIds[shortIdStr];
+            storedFields[dense] = snapshot.storedFields[shortIdStr];
+            dense++;
+        }
+    }
+    else {
+        for (const [shortIdStr, id] of Object.entries(snapshot.documentIds)) {
+            const shortId = parseInt(shortIdStr, 10);
+            externalIds[shortId] = id;
+            storedFields[shortId] = snapshot.storedFields[shortIdStr];
+        }
+    }
+    const idLookup = createIdToShortIdLookup(externalIds, resolvedNextId);
+    const matrixRows = useDense ? documentCount : nextId;
+    const matrixCells = matrixRows * fieldCount;
+    const fieldLengthScratch = new Array(matrixCells).fill(0);
+    for (const [shortIdStr, lengths] of Object.entries(snapshot.fieldLength)) {
+        const shortId = parseInt(shortIdStr, 10);
+        const row = shortIdRemap != null ? shortIdRemap[shortId] : shortId;
+        if (row === DISCARDED_DOC_ID)
+            continue;
+        for (let f = 0; f < fieldCount; f++) {
+            fieldLengthScratch[row * fieldCount + f] = (_c = lengths[f]) !== null && _c !== void 0 ? _c : 0;
+        }
+    }
+    const fieldLengthMatrix = materializeFieldLengthMatrix(fieldLengthScratch);
+    const avgFieldLength = new Float32Array(snapshot.averageFieldLength.length);
+    for (let i = 0; i < snapshot.averageFieldLength.length; i++) {
+        avgFieldLength[i] = snapshot.averageFieldLength[i];
+    }
+    const searchableMap = buildSearchableMapFromSnapshot(snapshot);
+    const flat = buildFlatPostingsFromSearchableMap(searchableMap, fieldCount, resolvedNextId, shortIdRemap);
+    return {
+        options: opts,
+        documentCount,
+        nextId: resolvedNextId,
+        fieldIds: snapshot.fieldIds,
+        fieldCount,
+        externalIds,
+        idLookup,
+        storedFields,
+        fieldLengthMatrix,
+        avgFieldLength,
+        index: flat.index,
+        termCount: flat.termCount,
+        postings: flat.postings,
+    };
+}
+
+/** Hard cap on the uncompressed payload, rejected before allocation (zstd-bomb guard).
+ *  This is the single trust boundary for untrusted snapshots: {@link readPayloadMeta} rejects
+ *  headers above this size; sync decompress uses the same cap via `maxOutputLength`.
+ *  A malicious header can still declare up to 1 GiB — no tighter native limit helps without
+ *  trusting `uncompressedLength` from that same header. Semantic integrity (length match,
+ *  payload CRC, per-section CRC) is enforced after decode. */
+const MSV5_MAX_UNCOMPRESSED_BYTES = 1024 * 1024 * 1024;
+// zstd landed in node:zlib at Node 22.15.0 (22.x line) / 23.8.0, where the whole family
+// (zstdCompress[Sync], zstdDecompressSync, createZstdDecompress) ships together — so probing one
+// member is enough to know if the runtime supports zstd. Checked at call time (not captured at
+// module load) so it stays mockable in tests. On older runtimes we degrade gracefully: writes fall
+// back to a raw (uncompressed) payload, reads of a zstd payload throw a clear, actionable error.
+function zstdAvailable() {
+    return typeof zlib.zstdCompressSync === 'function';
+}
+function zstdUnavailableReadError() {
+    return new Error('MSv5 snapshot is zstd-compressed, but this Node.js runtime lacks node:zlib zstd support '
+        + '(added in Node 22.15.0). Upgrade Node.js to read this snapshot, or re-save it from a '
+        + 'newer runtime to embed a raw (uncompressed) payload.');
+}
+let warnedZstdSaveFallback = false;
+function warnZstdSaveFallbackOnce() {
+    if (warnedZstdSaveFallback)
+        return;
+    warnedZstdSaveFallback = true;
+    process.emitWarning('node:zlib zstd APIs are unavailable (Node.js < 22.15.0); MSv5 snapshots are written with a '
+        + 'raw (uncompressed) payload. Upgrade to Node 22.15.0+ for compressed snapshots.', { code: 'MINISEARCH_MSV5_ZSTD_UNAVAILABLE' });
+}
+function assertPayloadFormatRev(buf) {
+    const rev = buf.readUInt16LE(MSV5_FORMAT_REV_OFFSET);
+    if (rev !== MSV5_FORMAT_REV_PAYLOAD) {
+        throw new Error(`MSv5 unsupported format revision ${rev}`);
+    }
+}
+function readPayloadMeta(fileBuf) {
+    const payloadOffset = fileBuf.readUInt32LE(MSV5_PAYLOAD_COMPRESSED_OFFSET);
+    const compressedLength = fileBuf.readUInt32LE(MSV5_PAYLOAD_COMPRESSED_LENGTH_OFFSET);
+    const uncompressedLength = fileBuf.readUInt32LE(MSV5_PAYLOAD_UNCOMPRESSED_LENGTH_OFFSET);
+    const payloadCrc32 = fileBuf.readUInt32LE(MSV5_PAYLOAD_CRC_OFFSET);
+    const payloadCodec = fileBuf.readUInt8(MSV5_PAYLOAD_CODEC_OFFSET);
+    if (uncompressedLength > MSV5_MAX_UNCOMPRESSED_BYTES) {
+        throw new Error('MSv5 payload exceeds 1 GiB limit');
+    }
+    return { payloadOffset, compressedLength, uncompressedLength, payloadCrc32, payloadCodec };
+}
+function concatRawSections(rawSections) {
+    const entries = [];
+    let uncompressedLength = 0;
+    for (const raw of rawSections) {
+        uncompressedLength = (uncompressedLength + 3) & -4;
+        entries.push({
+            fileOffset: uncompressedLength,
+            uncompressedLength: raw.length,
+            sectionCrc32: crc32Buffer(raw),
+        });
+        uncompressedLength += raw.length;
+    }
+    const uncompressed = Buffer.alloc(uncompressedLength);
+    for (let i = 0; i < rawSections.length; i++) {
+        rawSections[i].copy(uncompressed, entries[i].fileOffset);
+    }
+    return { uncompressed, entries };
+}
+/** Shared zstd encoder options for sync and async save paths.
+ *  - `pledgedSrcSize`: exact input size is known; lets libzstd size its window and buffers.
+ *  - `ZSTD_c_checksumFlag: 0`: MSv5 already stores payload + per-section CRC-32; frame checksum is redundant CPU.
+ *  Cast: `pledgedSrcSize` is supported at runtime by Node zlib but may lag in typings. */
+function msv5ZstdCompressOptions(uncompressed) {
+    return {
+        pledgedSrcSize: uncompressed.length,
+        params: {
+            [zlib.constants.ZSTD_c_compressionLevel]: MSV5_ZSTD_LEVEL,
+            [zlib.constants.ZSTD_c_checksumFlag]: 0,
+        },
+    };
+}
+/** Raw if below {@link MSV5_MIN_COMPRESS_BYTES}; else zstd when strictly smaller than raw. */
+function pickPayloadCodec(uncompressed, compressed) {
+    if (compressed.length < uncompressed.length) {
+        return { payload: compressed, codec: CODEC_ZSTD, zstdLevel: MSV5_ZSTD_LEVEL };
+    }
+    return { payload: uncompressed, codec: CODEC_RAW, zstdLevel: 0 };
+}
+function choosePayloadCodecSync(uncompressed) {
+    if (uncompressed.length < MSV5_MIN_COMPRESS_BYTES) {
+        return { payload: uncompressed, codec: CODEC_RAW, zstdLevel: 0 };
+    }
+    if (!zstdAvailable()) {
+        warnZstdSaveFallbackOnce();
+        return { payload: uncompressed, codec: CODEC_RAW, zstdLevel: 0 };
+    }
+    const compressed = zlib.zstdCompressSync(uncompressed, msv5ZstdCompressOptions(uncompressed));
+    return pickPayloadCodec(uncompressed, compressed);
+}
+/**
+ * Async zstd via {@link zstdCompress} (not {@link zstdCompressSync}).
+ * Same level and input yield the same *decompressed* payload (catalogue CRC matches sync),
+ * but the compressed blob is not guaranteed bit-identical — libzstd may pick a different
+ * frame layout; only `payload.length` in the header differs.
+ */
+function zstdCompressAsync(uncompressed) {
+    return new Promise((resolve, reject) => {
+        zlib.zstdCompress(uncompressed, msv5ZstdCompressOptions(uncompressed), (err, compressed) => {
+            if (err != null) {
+                reject(err);
+                return;
+            }
+            resolve(compressed);
+        });
+    });
+}
+async function choosePayloadCodecAsync(uncompressed) {
+    if (uncompressed.length < MSV5_MIN_COMPRESS_BYTES) {
+        return { payload: uncompressed, codec: CODEC_RAW, zstdLevel: 0 };
+    }
+    if (!zstdAvailable()) {
+        warnZstdSaveFallbackOnce();
+        return { payload: uncompressed, codec: CODEC_RAW, zstdLevel: 0 };
+    }
+    const compressed = await zstdCompressAsync(uncompressed);
+    return pickPayloadCodec(uncompressed, compressed);
+}
+function concatAndValidateSections(rawSections) {
+    if (rawSections.length !== MSV5_SECTION_COUNT) {
+        throw new Error(`MSv5 expects ${MSV5_SECTION_COUNT} sections, got ${rawSections.length}`);
+    }
+    const { uncompressed, entries } = concatRawSections(rawSections);
+    if (uncompressed.length > MSV5_MAX_UNCOMPRESSED_BYTES) {
+        throw new Error('MSv5 payload exceeds 1 GiB limit');
+    }
+    return { uncompressed, entries, payloadCrc32: crc32Buffer(uncompressed) };
+}
+/** Writes MSv5 header + section catalogue and appends the payload blob. */
+function buildMsv5AssembledFile(globalFlags, entries, uncompressedLength, payloadCrc32, payload, codec, zstdLevel) {
+    const out = Buffer.alloc(MSV5_HEADER_SIZE + payload.length);
+    out.write('MSv5', 0, 4, 'ascii');
+    out.writeUInt16LE(5, 4);
+    out.writeUInt16LE(globalFlags & 0xffff, 6);
+    out.writeUInt8(codec, MSV5_PAYLOAD_CODEC_OFFSET);
+    out.writeUInt8(zstdLevel, MSV5_ZSTD_LEVEL_OFFSET);
+    out.writeUInt16LE(MSV5_FORMAT_REV_PAYLOAD, MSV5_FORMAT_REV_OFFSET);
+    out.writeUInt32LE(MSV5_SECTION_COUNT, MSV5_SECTION_COUNT_OFFSET);
+    out.writeUInt32LE(MSV5_HEADER_SIZE, MSV5_PAYLOAD_COMPRESSED_OFFSET);
+    out.writeUInt32LE(payload.length, MSV5_PAYLOAD_COMPRESSED_LENGTH_OFFSET);
+    out.writeUInt32LE(uncompressedLength, MSV5_PAYLOAD_UNCOMPRESSED_LENGTH_OFFSET);
+    out.writeUInt32LE(payloadCrc32, MSV5_PAYLOAD_CRC_OFFSET);
+    let dirOff = MSV5_SECTION_DIR_OFFSET;
+    for (const e of entries) {
+        out.writeUInt32LE(e.fileOffset, dirOff);
+        out.writeUInt32LE(e.uncompressedLength, dirOff + 4);
+        out.writeUInt32LE(e.sectionCrc32, dirOff + 8);
+        dirOff += MSV5_SECTION_ENTRY_BYTES;
+    }
+    payload.copy(out, MSV5_HEADER_SIZE);
+    return {
+        buffer: out,
+        globalFlags,
+        compression: {
+            formatRev: MSV5_FORMAT_REV_PAYLOAD,
+            payloadCodec: codec,
+            zstdLevel,
+            uncompressedLength,
+            compressedLength: payload.length,
+            payloadCrc32,
+            sections: entries.map((e, sectionId) => ({
+                sectionId,
+                uncompressedOffset: e.fileOffset,
+                uncompressedLength: e.uncompressedLength,
+                sectionCrc32: e.sectionCrc32,
+            })),
+        },
+    };
+}
+/**
+ * MSv5 on disk: header + catalogue (uncompressed offsets) + **one** payload blob
+ * (raw concatenation or a single zstd stream over it).
+ */
+function assembleMsv5File(globalFlags, rawSections) {
+    const { uncompressed, entries, payloadCrc32 } = concatAndValidateSections(rawSections);
+    const { payload, codec, zstdLevel } = choosePayloadCodecSync(uncompressed);
+    return buildMsv5AssembledFile(globalFlags, entries, uncompressed.length, payloadCrc32, payload, codec, zstdLevel);
+}
+async function assembleMsv5FileAsync(globalFlags, rawSections) {
+    const { uncompressed, entries, payloadCrc32 } = concatAndValidateSections(rawSections);
+    const { payload, codec, zstdLevel } = await choosePayloadCodecAsync(uncompressed);
+    return buildMsv5AssembledFile(globalFlags, entries, uncompressed.length, payloadCrc32, payload, codec, zstdLevel);
+}
+function readMsv5SectionDirectory(buf) {
+    if (buf.length < MSV5_HEADER_SIZE) {
+        throw new Error('MSv5 buffer too short for header');
+    }
+    const sectionCount = buf.readUInt32LE(MSV5_SECTION_COUNT_OFFSET);
+    if (sectionCount !== MSV5_SECTION_COUNT) {
+        throw new Error(`MSv5 section count mismatch: ${sectionCount}`);
+    }
+    assertPayloadFormatRev(buf);
+    const entries = [];
+    let dirOff = MSV5_SECTION_DIR_OFFSET;
+    for (let i = 0; i < sectionCount; i++) {
+        entries.push({
+            fileOffset: buf.readUInt32LE(dirOff),
+            uncompressedLength: buf.readUInt32LE(dirOff + 4),
+            sectionCrc32: buf.readUInt32LE(dirOff + 8),
+        });
+        dirOff += MSV5_SECTION_ENTRY_BYTES;
+    }
+    return entries;
+}
+function verifySectionCrc(section, expected) {
+    if (crc32Buffer(section) !== expected) {
+        throw new Error('MSv5 section CRC mismatch');
+    }
+}
+/** Slice each section out of a fully materialized payload (zero-copy when 4-byte aligned). */
+function sectionsFromPayload(payload, directory, payloadCrc32) {
+    if (crc32Buffer(payload) !== payloadCrc32) {
+        throw new Error('MSv5 payload CRC mismatch');
+    }
+    return directory.map((entry) => {
+        const slice = payload.subarray(entry.fileOffset, entry.fileOffset + entry.uncompressedLength);
+        verifySectionCrc(slice, entry.sectionCrc32);
+        if ((payload.byteOffset + entry.fileOffset) % 4 === 0)
+            return slice;
+        const out = Buffer.alloc(entry.uncompressedLength);
+        slice.copy(out, 0);
+        return out;
+    });
+}
+/** Streaming zstd reader: keeps only one section in memory at a time.
+ *  No `maxOutputLength` on {@link createZstdDecompress}: output is bounded by accumulating
+ *  `streamOffset` against the header's `uncompressedLength` (same 1 GiB cap checked upfront).
+ *  Sync load uses `maxOutputLength` instead because it materializes the whole payload at once. */
+function collectZstdPayloadSections(directory, uncompressedLength, payloadCrc32) {
+    if (uncompressedLength > MSV5_MAX_UNCOMPRESSED_BYTES) {
+        throw new Error('MSv5 payload exceeds 1 GiB limit');
+    }
+    const sections = new Array(directory.length);
+    let sectionId = 0;
+    let streamOffset = 0;
+    let current = null;
+    let payloadCrc = 0;
+    function emitEmptySections() {
+        while (sectionId < directory.length
+            && directory[sectionId].uncompressedLength === 0
+            && directory[sectionId].fileOffset === streamOffset) {
+            verifySectionCrc(Buffer.alloc(0), directory[sectionId].sectionCrc32);
+            sections[sectionId] = Buffer.alloc(0);
+            sectionId++;
+        }
+    }
+    function consume(chunk) {
+        if (streamOffset + chunk.length > uncompressedLength) {
+            throw new Error('MSv5 zstd payload exceeds declared length');
+        }
+        payloadCrc = crc32Update(payloadCrc, chunk);
+        let off = 0;
+        while (off < chunk.length) {
+            emitEmptySections();
+            if (sectionId >= directory.length) {
+                streamOffset += chunk.length - off;
+                return;
+            }
+            const entry = directory[sectionId];
+            if (streamOffset < entry.fileOffset) {
+                const skip = Math.min(entry.fileOffset - streamOffset, chunk.length - off);
+                streamOffset += skip;
+                off += skip;
+                continue;
+            }
+            if (current == null) {
+                current = Buffer.allocUnsafe(entry.uncompressedLength);
+            }
+            const written = streamOffset - entry.fileOffset;
+            const take = Math.min(entry.uncompressedLength - written, chunk.length - off);
+            chunk.copy(current, written, off, off + take);
+            streamOffset += take;
+            off += take;
+            if (written + take === entry.uncompressedLength) {
+                verifySectionCrc(current, entry.sectionCrc32);
+                sections[sectionId] = current;
+                current = null;
+                sectionId++;
+            }
+        }
+    }
+    function finish() {
+        emitEmptySections();
+        if (streamOffset !== uncompressedLength || sectionId !== directory.length) {
+            throw new Error('MSv5 zstd decompressed length mismatch');
+        }
+        if (payloadCrc !== payloadCrc32) {
+            throw new Error('MSv5 payload CRC mismatch');
+        }
+    }
+    return { sections, consume, finish };
+}
+function loadMsv5SectionsFromZstdStream(compressed, directory, uncompressedLength, payloadCrc32) {
+    return new Promise((resolve, reject) => {
+        const collector = collectZstdPayloadSections(directory, uncompressedLength, payloadCrc32);
+        const stream = zlib.createZstdDecompress();
+        stream.on('data', (chunk) => {
+            try {
+                collector.consume(chunk);
+            }
+            catch (err) {
+                stream.destroy(err);
+            }
+        });
+        stream.on('error', reject);
+        stream.on('end', () => {
+            try {
+                collector.finish();
+                resolve(collector.sections);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        stream.end(compressed);
+    });
+}
+function validatePayloadDirectory(directory, uncompressedLength) {
+    let prevEnd = 0;
+    for (const entry of directory) {
+        if ((entry.fileOffset & 3) !== 0) {
+            throw new Error('MSv5 section offset not aligned');
+        }
+        if (entry.fileOffset < prevEnd) {
+            throw new Error('MSv5 section offsets not monotonic');
+        }
+        if (entry.fileOffset + entry.uncompressedLength > uncompressedLength) {
+            throw new Error('MSv5 section out of uncompressed bounds');
+        }
+        prevEnd = entry.fileOffset + entry.uncompressedLength;
+    }
+    if (prevEnd !== uncompressedLength) {
+        throw new Error('MSv5 uncompressed payload length mismatch');
+    }
+}
+/** Shared validation + bounds for both the sync and async load paths. */
+function preparePayload(fileBuf, directory) {
+    assertPayloadFormatRev(fileBuf);
+    const { payloadOffset, compressedLength, uncompressedLength, payloadCrc32, payloadCodec } = readPayloadMeta(fileBuf);
+    validatePayloadDirectory(directory, uncompressedLength);
+    if (payloadOffset !== MSV5_HEADER_SIZE || payloadOffset + compressedLength > fileBuf.length) {
+        throw new Error('MSv5 payload out of bounds');
+    }
+    if (payloadCodec === CODEC_RAW && compressedLength !== uncompressedLength) {
+        throw new Error('MSv5 raw payload length mismatch');
+    }
+    return {
+        payloadCodec,
+        slice: fileBuf.subarray(payloadOffset, payloadOffset + compressedLength),
+        uncompressedLength,
+        payloadCrc32,
+    };
+}
+/** Synchronous load; peak RAM ≈ full uncompressed payload (use the async path to bound it). */
+function loadMsv5Sections(fileBuf, directory) {
+    const { payloadCodec, slice, uncompressedLength, payloadCrc32 } = preparePayload(fileBuf, directory);
+    if (payloadCodec === CODEC_RAW) {
+        return sectionsFromPayload(slice, directory, payloadCrc32);
+    }
+    if (payloadCodec === CODEC_ZSTD) {
+        if (!zstdAvailable()) {
+            throw zstdUnavailableReadError();
+        }
+        // Native cap matches readPayloadMeta's 1 GiB limit (see MSV5_MAX_UNCOMPRESSED_BYTES).
+        // Using header `uncompressedLength` here would only help when the header understates
+        // the zstd stream but the attacker can inflate the header too — same worst case.
+        const decoded = zlib.zstdDecompressSync(slice, {
+            maxOutputLength: MSV5_MAX_UNCOMPRESSED_BYTES,
+        });
+        if (decoded.length !== uncompressedLength) {
+            throw new Error('MSv5 zstd decompressed length mismatch');
+        }
+        return sectionsFromPayload(decoded, directory, payloadCrc32);
+    }
+    throw new Error(`MSv5 unknown payload codec ${payloadCodec}`);
+}
+/** Streaming load; peak main-thread RAM ≈ largest single section (+ file buffer). */
+async function loadMsv5SectionsAsync(fileBuf, directory) {
+    const { payloadCodec, slice, uncompressedLength, payloadCrc32 } = preparePayload(fileBuf, directory);
+    if (payloadCodec === CODEC_RAW) {
+        return sectionsFromPayload(slice, directory, payloadCrc32);
+    }
+    if (payloadCodec === CODEC_ZSTD) {
+        if (!zstdAvailable()) {
+            throw zstdUnavailableReadError();
+        }
+        return loadMsv5SectionsFromZstdStream(slice, directory, uncompressedLength, payloadCrc32);
+    }
+    throw new Error(`MSv5 unknown payload codec ${payloadCodec}`);
+}
+function isMsv5Buffer(buf) {
+    return buf.length >= 4 && buf.toString('ascii', 0, 4) === 'MSv5';
+}
+function readMsv5GlobalFlags(buf) {
+    return buf.readUInt16LE(6);
+}
+
+function validateTreeShape(shape, termCount) {
+    if (!Array.isArray(shape)) {
+        throw invalidFrozenIndex('treeShape node must be an array');
+    }
+    for (const entry of shape) {
+        if (!Array.isArray(entry) || entry.length !== 2) {
+            throw invalidFrozenIndex('treeShape entry must be a [key, value] pair');
+        }
+        const [key, value] = entry;
+        if (key === LEAF) {
+            const idx = value;
+            if (!Number.isInteger(idx) || idx < 0 || idx >= termCount) {
+                throw invalidFrozenIndex(`treeShape leaf term index out of range: ${idx}`);
+            }
+        }
+        else {
+            validateTreeShape(value, termCount);
+        }
+    }
+}
+function termCountOf(snap) {
+    return snap.postings.termCount;
+}
+/**
+ * Numeric/structural invariants shared by both the decode path (untrusted binary)
+ * and the build path (trusted internal code).
+ */
+function validateFrozenSnapshotNumeric(snap) {
+    if (snap.fieldCount <= 0) {
+        throw invalidFrozenIndex('fieldCount must be positive');
+    }
+    if (snap.nextId < 0 || snap.nextId >= 0xffffffff) {
+        throw invalidFrozenIndex('nextId out of range');
+    }
+    if (snap.documentCount < 0 || snap.documentCount > snap.nextId) {
+        throw invalidFrozenIndex('documentCount inconsistent with nextId');
+    }
+    if (snap.fieldLengthMatrix.length !== snap.nextId * snap.fieldCount) {
+        throw invalidFrozenIndex('fieldLengthMatrix size mismatch');
+    }
+    if (snap.avgFieldLength.length !== snap.fieldCount) {
+        throw invalidFrozenIndex('avgFieldLength size mismatch');
+    }
+    validateFrozenPostingsLayout(snap.postings, snap.documentCount, snap.nextId, detail => {
+        throw invalidFrozenIndex(detail);
+    });
+    const indexedFields = Object.keys(snap.fieldIds);
+    if (indexedFields.length !== snap.fieldCount) {
+        throw invalidFrozenIndex('fieldIds count mismatch');
+    }
+    for (let f = 0; f < snap.fieldCount; f++) {
+        const found = indexedFields.some(name => snap.fieldIds[name] === f);
+        if (!found) {
+            throw invalidFrozenIndex(`missing field id ${f}`);
+        }
+    }
+}
+function readFieldNamesSection(buf, fieldNamesOff, fieldCount, externalIdsOff) {
+    const fieldNames = [];
+    let o = fieldNamesOff;
+    for (let f = 0; f < fieldCount; f++) {
+        const { value, next } = readLengthPrefixedUtf8(buf, o);
+        fieldNames.push(value);
+        o = next;
+    }
+    if (o !== externalIdsOff) {
+        throw invalidFrozenIndex('field names section size mismatch');
+    }
+    return fieldNames;
+}
+function readExternalIdsSection(buf, externalIdsOff, nextId, storedOff) {
+    const externalIds = new Array(nextId);
+    let o = externalIdsOff;
+    for (let i = 0; i < nextId; i++) {
+        const { value, next } = readExternalId(buf, o);
+        externalIds[i] = value;
+        o = next;
+    }
+    if (o !== storedOff) {
+        throw invalidFrozenIndex('external ids section size mismatch');
+    }
+    return externalIds;
+}
+function readStoredFieldsSection(buf, storedOff, nextId, sectionEnd) {
+    const storedFields = new Array(nextId);
+    const tableEnd = storedOff + nextId * 4;
+    if (tableEnd > sectionEnd) {
+        throw invalidFrozenIndex('stored fields table out of bounds');
+    }
+    for (let i = 0; i < nextId; i++) {
+        const rel = buf.readUInt32LE(storedOff + i * 4);
+        if (rel === 0) {
+            storedFields[i] = undefined;
+            continue;
+        }
+        const entryOff = tableEnd + rel - 1;
+        if (entryOff + 4 > sectionEnd) {
+            throw invalidFrozenIndex('stored fields entry offset out of bounds');
+        }
+        const jsonLen = buf.readUInt32LE(entryOff);
+        const jsonStart = entryOff + 4;
+        const jsonEnd = jsonStart + jsonLen;
+        if (jsonEnd > sectionEnd) {
+            throw invalidFrozenIndex('stored fields JSON out of bounds');
+        }
+        storedFields[i] = JSON.parse(buf.toString('utf8', jsonStart, jsonEnd));
+    }
+    return storedFields;
+}
+/** Validate structural invariants of a decoded or assembled frozen snapshot. */
+function validateFrozenSnapshot(snap) {
+    validateFrozenSnapshotNumeric(snap);
+    const termCount = termCountOf(snap);
+    if (snap.packedTermIndex != null) {
+        validateFrozenTermIndexLeaves(snap.packedTermIndex, termCount);
+    }
+    else if (snap.termTree != null) {
+        validateTermTreeLeaves(snap.termTree, termCount);
+    }
+    else {
+        validateTreeShape(snap.treeShape, termCount);
+    }
+}
+function fieldNamesFromFieldIds(fieldIds) {
+    const names = Object.keys(fieldIds);
+    names.sort((a, b) => fieldIds[a] - fieldIds[b]);
+    return names;
+}
+/** Core with explicit {@link termCountOf} (no dictionary section). */
+function buildCoreSectionWithTermCount(snap) {
+    const out = Buffer.alloc(16);
+    out.writeUInt32LE(snap.documentCount, 0);
+    out.writeUInt32LE(snap.nextId, 4);
+    out.writeUInt32LE(snap.fieldCount, 8);
+    out.writeUInt32LE(termCountOf(snap), 12);
+    return out;
+}
+function buildFieldNamesSection(fieldNames) {
+    const chunks = [];
+    for (const name of fieldNames) {
+        const body = Buffer.from(name, 'utf8');
+        const header = Buffer.alloc(4);
+        header.writeUInt32LE(body.length, 0);
+        chunks.push(header, body);
+    }
+    return Buffer.concat(chunks);
+}
+function buildExternalIdsSection(externalIds, nextId) {
+    const chunks = [];
+    for (let i = 0; i < nextId; i++) {
+        writeExternalId(chunks, externalIds[i]);
+    }
+    return Buffer.concat(chunks);
+}
+function buildStoredFieldsSection(storedFields, nextId) {
+    const table = Buffer.alloc(nextId * 4);
+    const heapChunks = [];
+    let heapOff = 0;
+    for (let i = 0; i < nextId; i++) {
+        const row = storedFields[i];
+        if (row == null) {
+            table.writeUInt32LE(0, i * 4);
+            continue;
+        }
+        table.writeUInt32LE(heapOff + 1, i * 4);
+        const json = Buffer.from(JSON.stringify(row), 'utf8');
+        const entry = Buffer.alloc(4 + json.length);
+        entry.writeUInt32LE(json.length, 0);
+        json.copy(entry, 4);
+        heapChunks.push(entry);
+        heapOff += entry.length;
+    }
+    return Buffer.concat([table, ...heapChunks]);
+}
+function validateTermTreeLeaves(tree, termCount) {
+    for (const [key, val] of tree) {
+        if (key === LEAF) {
+            const idx = val;
+            if (!Number.isInteger(idx) || idx < 0 || idx >= termCount) {
+                throw invalidFrozenIndex(`term tree leaf index out of range: ${idx}`);
+            }
+        }
+        else {
+            validateTermTreeLeaves(val, termCount);
+        }
+    }
+}
+function deserializeTermIndexTree(shape) {
+    const tree = new Map();
+    for (const [key, value] of shape) {
+        if (key === LEAF) {
+            tree.set(LEAF, value);
+        }
+        else {
+            tree.set(key, deserializeTermIndexTree(value));
+        }
+    }
+    return tree;
+}
+
+/** Global wire flags for {@link FreqArray} width. */
+function freqWireFlags(freqs) {
+    if (freqs instanceof Uint16Array)
+        return FLAG_FREQ_U16;
+    return 0;
+}
+function readFreqsSection(buf, globalFlags, postingCount) {
+    if ((globalFlags & FLAG_FREQ_U16) !== 0) {
+        if (buf.length !== postingCount * 2) {
+            throw invalidFrozenIndex('allFreqs u16 size mismatch');
+        }
+        return postingCount === 0
+            ? new Uint16Array(0)
+            : new Uint16Array(buf.buffer, buf.byteOffset, postingCount);
+    }
+    if (buf.length !== postingCount) {
+        throw invalidFrozenIndex('allFreqs u8 size mismatch');
+    }
+    return postingCount === 0
+        ? new Uint8Array(0)
+        : new Uint8Array(buf.buffer, buf.byteOffset, postingCount);
+}
+
+function msv5PostingsFlags(postings) {
+    let flags = 0;
+    if (postings.layout === 'sparse')
+        flags |= FLAG_SPARSE_LAYOUT;
+    if (postings.docIdWidth === 16)
+        flags |= FLAG_DOC_ID_16;
+    if (postings.sparseFieldIdWidth === 16)
+        flags |= FLAG_FIELD_ID_16;
+    return flags;
+}
+function buildMsv5PostingsSections(postings) {
+    if (postings.layout === 'dense') {
+        if (postings.denseOffsets == null || postings.denseLengths == null) {
+            throw invalidFrozenIndex('dense postings missing offset tables');
+        }
+        return {
+            flags: msv5PostingsFlags(postings),
+            meta: bufferFromView(postings.denseOffsets),
+            fields: bufferFromView(postings.denseLengths),
+            optional: Buffer.alloc(0),
+            docIds: bufferFromView(postings.allDocIds),
+            freqs: bufferFromView(postings.allFreqs),
+        };
+    }
+    if (postings.sparseTermStarts == null
+        || postings.sparseFieldIds == null
+        || postings.sparseOffsets == null
+        || postings.sparseLengths == null) {
+        throw invalidFrozenIndex('sparse postings missing tables');
+    }
+    const offBuf = bufferFromView(postings.sparseOffsets);
+    const lenBuf = bufferFromView(postings.sparseLengths);
+    const optional = Buffer.alloc(4 + offBuf.length + lenBuf.length);
+    optional.writeUInt32LE(offBuf.length, 0);
+    offBuf.copy(optional, 4);
+    lenBuf.copy(optional, 4 + offBuf.length);
+    return {
+        flags: msv5PostingsFlags(postings),
+        meta: bufferFromView(postings.sparseTermStarts),
+        fields: bufferFromView(postings.sparseFieldIds),
+        optional,
+        docIds: bufferFromView(postings.allDocIds),
+        freqs: bufferFromView(postings.allFreqs),
+    };
+}
+function decodeMsv5PostingsSections(flags, fieldCount, termCount, nextId, meta, fields, optional, docIds, freqs) {
+    const sparse = (flags & FLAG_SPARSE_LAYOUT) !== 0;
+    const docId16 = (flags & FLAG_DOC_ID_16) !== 0;
+    const fieldId16 = (flags & FLAG_FIELD_ID_16) !== 0;
+    const readDocIds = () => {
+        if (docIds.length === 0)
+            return docId16 ? new Uint16Array(0) : new Uint32Array(0);
+        if (docId16)
+            return readUint16Array(docIds, 0, docIds.length);
+        return readUint32Array(docIds, 0, docIds.length);
+    };
+    const allDocIds = readDocIds();
+    const allFreqs = readFreqsSection(freqs, flags, allDocIds.length);
+    if (sparse) {
+        const sparseFieldIdWidth = fieldId16 ? 16 : 8;
+        const offLen = optional.readUInt32LE(0);
+        if (4 + offLen > optional.length) {
+            throw invalidFrozenIndex('sparse optional section truncated');
+        }
+        const sparseOffsets = readUint32Array(optional, 4, offLen);
+        const sparseLengths = readUint32Array(optional, 4 + offLen, optional.length - 4 - offLen);
+        const sparseTermStarts = readUint32Array(meta, 0, meta.length);
+        const sparseFieldIds = readFieldIdArray(fields, 0, fields.length, sparseFieldIdWidth);
+        return {
+            fieldCount,
+            termCount,
+            nextId,
+            layout: 'sparse',
+            docIdWidth: docId16 ? 16 : 32,
+            sparseFieldIdWidth,
+            allDocIds,
+            allFreqs,
+            denseOffsets: null,
+            denseLengths: null,
+            sparseTermStarts,
+            sparseFieldIds,
+            sparseOffsets,
+            sparseLengths,
+        };
+    }
+    const denseOffsets = readUint32Array(meta, 0, meta.length);
+    const denseLengths = readUint32Array(fields, 0, fields.length);
+    return {
+        fieldCount,
+        termCount,
+        nextId,
+        layout: 'dense',
+        docIdWidth: docId16 ? 16 : 32,
+        sparseFieldIdWidth: null,
+        allDocIds,
+        allFreqs,
+        denseOffsets,
+        denseLengths,
+        sparseTermStarts: null,
+        sparseFieldIds: null,
+        sparseOffsets: null,
+        sparseLengths: null,
+    };
+}
+
+const TREE_SECTION_HEADER_BYTES = 16;
+function columnWidthCode(arr) {
+    if (arr instanceof Uint8Array)
+        return 0;
+    if (arr instanceof Uint16Array)
+        return 1;
+    return 2;
+}
+function columnWidthFlagsFromTree(tree) {
+    const cols = [
+        tree.nodeEdgeOffset,
+        tree.nodeValue,
+        tree.nodeLeafOrder,
+        tree.edgeLabelStart,
+        tree.edgeLabelLength,
+        tree.edgeChild,
+    ];
+    if (cols.length !== MSV5_TREE_COLUMN_COUNT) {
+        throw new Error('MSv5 tree column count mismatch');
+    }
+    let flags = 0;
+    for (let i = 0; i < cols.length; i++) {
+        flags |= columnWidthCode(cols[i]) << (i * 2);
+    }
+    return flags;
+}
+function pad4(n) {
+    return (n + 3) & -4;
+}
+function appendColumn(chunks, arr) {
+    const raw = Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
+    chunks.push(raw);
+    const pad = pad4(raw.length) - raw.length;
+    if (pad > 0)
+        chunks.push(Buffer.alloc(pad));
+}
+function buildTermTreeSectionColumnar(tree) {
+    const header = Buffer.alloc(TREE_SECTION_HEADER_BYTES);
+    header.writeUInt32LE(tree.size, 0);
+    header.writeUInt32LE(tree.nodeCount, 4);
+    header.writeUInt32LE(tree.edgeCount, 8);
+    header.writeUInt32LE(columnWidthFlagsFromTree(tree), 12);
+    const chunks = [header];
+    appendColumn(chunks, tree.nodeEdgeOffset);
+    appendColumn(chunks, tree.nodeValue);
+    appendColumn(chunks, tree.nodeLeafOrder);
+    appendColumn(chunks, tree.edgeLabelStart);
+    appendColumn(chunks, tree.edgeLabelLength);
+    appendColumn(chunks, tree.edgeChild);
+    const labelBuf = Buffer.from(tree.labelHeap, 'utf8');
+    chunks.push(labelBuf);
+    return Buffer.concat(chunks);
+}
+function widthFromFlags(flags, columnIndex) {
+    const code = (flags >> (columnIndex * 2)) & 3;
+    if (code === 0)
+        return 1;
+    if (code === 1)
+        return 2;
+    if (code === 2)
+        return 4;
+    throw invalidFrozenIndex(`invalid tree column width code ${code}`);
+}
+function readColumn(buf, offset, elementCount, width) {
+    const byteLength = elementCount * width;
+    const padded = pad4(byteLength);
+    if (offset + padded > buf.length) {
+        throw invalidFrozenIndex('term tree column truncated');
+    }
+    let arr;
+    if (width === 1) {
+        arr = elementCount === 0
+            ? new Uint8Array(0)
+            : new Uint8Array(buf.buffer, buf.byteOffset + offset, elementCount);
+    }
+    else if (width === 2) {
+        // Columns are pad4-aligned at encode time; section buffers are 4-aligned in MSv5 payloads.
+        if (offset % 2 !== 0) {
+            throw invalidFrozenIndex('term tree Uint16 column misaligned');
+        }
+        arr = elementCount === 0
+            ? new Uint16Array(0)
+            : new Uint16Array(buf.buffer, buf.byteOffset + offset, elementCount);
+    }
+    else {
+        if (offset % 4 !== 0) {
+            throw invalidFrozenIndex('term tree Uint32 column misaligned');
+        }
+        arr = elementCount === 0
+            ? new Uint32Array(0)
+            : new Uint32Array(buf.buffer, buf.byteOffset + offset, elementCount);
+    }
+    return { arr, next: offset + padded };
+}
+function readPackedTermTreeSectionColumnar(buf, termCount) {
+    if (buf.length < TREE_SECTION_HEADER_BYTES) {
+        throw invalidFrozenIndex('term tree section too short');
+    }
+    const size = buf.readUInt32LE(0);
+    const nodeCount = buf.readUInt32LE(4);
+    const edgeCount = buf.readUInt32LE(8);
+    const widthFlags = buf.readUInt32LE(12);
+    if (size !== termCount) {
+        throw invalidFrozenIndex('term tree termCount mismatch');
+    }
+    let o = TREE_SECTION_HEADER_BYTES;
+    const edgeOffLen = nodeCount + 1;
+    const edgeOff = readColumn(buf, o, edgeOffLen, widthFromFlags(widthFlags, 0));
+    o = edgeOff.next;
+    const nVal = readColumn(buf, o, nodeCount, widthFromFlags(widthFlags, 1));
+    o = nVal.next;
+    const nLeaf = readColumn(buf, o, nodeCount, widthFromFlags(widthFlags, 2));
+    o = nLeaf.next;
+    const eStart = readColumn(buf, o, edgeCount, widthFromFlags(widthFlags, 3));
+    o = eStart.next;
+    const eLen = readColumn(buf, o, edgeCount, widthFromFlags(widthFlags, 4));
+    o = eLen.next;
+    const eChild = readColumn(buf, o, edgeCount, widthFromFlags(widthFlags, 5));
+    o = eChild.next;
+    if (o > buf.length) {
+        throw invalidFrozenIndex('term tree label heap out of bounds');
+    }
+    const labelHeap = o === buf.length ? '' : buf.toString('utf8', o, buf.length);
+    const data = {
+        size,
+        nodeCount,
+        edgeCount,
+        labelHeap,
+        nodeEdgeOffset: edgeOff.arr,
+        nodeValue: nVal.arr,
+        nodeLeafOrder: nLeaf.arr,
+        edgeLabelStart: eStart.arr,
+        edgeLabelLength: eLen.arr,
+        edgeChild: eChild.arr,
+    };
+    const tree = PackedRadixTree.fromData(data);
+    validateFrozenTermIndexLeaves(tree, termCount);
+    return tree;
+}
+
+function resolvePackedTree(snap, termTree, packedTermIndex) {
+    const termCount = termCountOf(snap);
+    const packed = packedTermIndex !== null && packedTermIndex !== void 0 ? packedTermIndex : snap.packedTermIndex;
+    if (packed != null) {
+        validateFrozenTermIndexLeaves(packed, termCount);
+        return packed;
+    }
+    const tree = deserializeTermIndexTree(snap.treeShape);
+    validateTermTreeLeaves(tree, termCount);
+    return fromRadixTree(tree, termCount);
+}
+function encodeFrozenSnapshotMsv5(snap, termTree, packedTermIndex) {
+    var _a;
+    validateFrozenSnapshotNumeric(snap);
+    const fieldNames = (_a = snap.fieldNames) !== null && _a !== void 0 ? _a : fieldNamesFromFieldIds(snap.fieldIds);
+    if (fieldNames.length !== snap.fieldCount) {
+        throw invalidFrozenIndex('fieldNames length mismatch');
+    }
+    const packed = resolvePackedTree(snap, termTree, packedTermIndex);
+    const postingsWire = buildMsv5PostingsSections(snap.postings);
+    const flFlags = fieldLengthMatrixWireFlags(snap.fieldLengthMatrix);
+    const freqFlags = freqWireFlags(snap.postings.allFreqs);
+    const globalFlags = postingsWire.flags | flFlags | freqFlags;
+    const rawSections = [
+        buildCoreSectionWithTermCount(snap),
+        buildFieldNamesSection(fieldNames),
+        buildExternalIdsSection(snap.externalIds, snap.nextId),
+        buildStoredFieldsSection(snap.storedFields, snap.nextId),
+        buildTermTreeSectionColumnar(packed),
+        bufferFromView(snap.avgFieldLength),
+        buildFieldLengthMatrixSection(snap.fieldLengthMatrix),
+        postingsWire.meta,
+        postingsWire.fields,
+        postingsWire.optional,
+        postingsWire.docIds,
+        postingsWire.freqs,
+    ];
+    return assembleMsv5File(globalFlags, rawSections).buffer;
+}
+async function encodeFrozenSnapshotMsv5Async(snap, termTree, packedTermIndex) {
+    var _a;
+    validateFrozenSnapshotNumeric(snap);
+    const fieldNames = (_a = snap.fieldNames) !== null && _a !== void 0 ? _a : fieldNamesFromFieldIds(snap.fieldIds);
+    if (fieldNames.length !== snap.fieldCount) {
+        throw invalidFrozenIndex('fieldNames length mismatch');
+    }
+    const packed = resolvePackedTree(snap, termTree, packedTermIndex);
+    const postingsWire = buildMsv5PostingsSections(snap.postings);
+    const flFlags = fieldLengthMatrixWireFlags(snap.fieldLengthMatrix);
+    const freqFlags = freqWireFlags(snap.postings.allFreqs);
+    const globalFlags = postingsWire.flags | flFlags | freqFlags;
+    const rawSections = [
+        buildCoreSectionWithTermCount(snap),
+        buildFieldNamesSection(fieldNames),
+        buildExternalIdsSection(snap.externalIds, snap.nextId),
+        buildStoredFieldsSection(snap.storedFields, snap.nextId),
+        buildTermTreeSectionColumnar(packed),
+        bufferFromView(snap.avgFieldLength),
+        buildFieldLengthMatrixSection(snap.fieldLengthMatrix),
+        postingsWire.meta,
+        postingsWire.fields,
+        postingsWire.optional,
+        postingsWire.docIds,
+        postingsWire.freqs,
+    ];
+    return (await assembleMsv5FileAsync(globalFlags, rawSections)).buffer;
+}
+
+function validateMsv5Container(buf) {
+    if (!isMsv5Buffer(buf)) {
+        throw invalidFrozenIndex('not a frozen binary snapshot');
+    }
+    const version = buf.readUInt16LE(4);
+    if (version !== 5) {
+        throw invalidFrozenIndex(`unsupported frozen snapshot version=${version}`);
+    }
+    const globalFlags = readMsv5GlobalFlags(buf);
+    const directory = readMsv5SectionDirectory(buf);
+    const payloadOff = buf.readUInt32LE(MSV5_PAYLOAD_COMPRESSED_OFFSET);
+    const compressedLen = buf.readUInt32LE(MSV5_PAYLOAD_COMPRESSED_LENGTH_OFFSET);
+    if (payloadOff !== MSV5_HEADER_SIZE || payloadOff + compressedLen > buf.length) {
+        throw invalidFrozenIndex('frozen snapshot payload out of bounds');
+    }
+    return { globalFlags, directory };
+}
+function decodeMsv5Sections(globalFlags, sections) {
+    const core = sections[0 /* Msv5SectionId.Core */];
+    if (core.length !== 16) {
+        throw invalidFrozenIndex('core section size mismatch');
+    }
+    const documentCount = core.readUInt32LE(0);
+    const nextId = core.readUInt32LE(4);
+    const fieldCount = core.readUInt32LE(8);
+    const termCount = core.readUInt32LE(12);
+    const fieldNames = readFieldNamesSection(sections[1 /* Msv5SectionId.FieldNames */], 0, fieldCount, sections[1 /* Msv5SectionId.FieldNames */].length);
+    const fieldIds = {};
+    for (let f = 0; f < fieldNames.length; f++) {
+        fieldIds[fieldNames[f]] = f;
+    }
+    const externalIds = readExternalIdsSection(sections[2 /* Msv5SectionId.ExternalIds */], 0, nextId, sections[2 /* Msv5SectionId.ExternalIds */].length);
+    const storedFields = readStoredFieldsSection(sections[3 /* Msv5SectionId.StoredFields */], 0, nextId, sections[3 /* Msv5SectionId.StoredFields */].length);
+    const packedTermIndex = readPackedTermTreeSectionColumnar(sections[4 /* Msv5SectionId.TermTree */], termCount);
+    const avgBuf = sections[5 /* Msv5SectionId.AvgFieldLength */];
+    const avgFieldLength = readFloat32Array(avgBuf, 0, avgBuf.length);
+    const fieldLengthMatrix = readFieldLengthMatrixSection(sections[6 /* Msv5SectionId.FieldLengthMatrix */], globalFlags, nextId * fieldCount);
+    const postings = decodeMsv5PostingsSections(globalFlags, fieldCount, termCount, nextId, sections[7 /* Msv5SectionId.PostMeta */], sections[8 /* Msv5SectionId.PostFields */], sections[9 /* Msv5SectionId.PostOptional */], sections[10 /* Msv5SectionId.AllDocIds */], sections[11 /* Msv5SectionId.AllFreqs */]);
+    if (postings.termCount !== termCount) {
+        throw invalidFrozenIndex('core termCount mismatch with postings');
+    }
+    const snap = {
+        documentCount,
+        nextId,
+        fieldIds,
+        fieldCount,
+        fieldNames,
+        avgFieldLength,
+        externalIds,
+        storedFields,
+        fieldLengthMatrix,
+        treeShape: [],
+        packedTermIndex,
+        postings,
+    };
+    validateFrozenSnapshot(snap);
+    return snap;
+}
+function decodeFrozenSnapshotMsv5(buf) {
+    const { globalFlags, directory } = validateMsv5Container(buf);
+    return decodeMsv5Sections(globalFlags, loadMsv5Sections(buf, directory));
+}
+async function decodeFrozenSnapshotMsv5Async(buf) {
+    const { globalFlags, directory } = validateMsv5Container(buf);
+    return decodeMsv5Sections(globalFlags, await loadMsv5SectionsAsync(buf, directory));
+}
+
+/** Encode a frozen snapshot as a binary buffer. */
+function encodeFrozenSnapshot(snap, termTree, packedTermIndex) {
+    return encodeFrozenSnapshotMsv5(snap, termTree, packedTermIndex);
+}
+/** Async encoder; uses non-blocking zstd compression for large payloads. */
+function encodeFrozenSnapshotAsync(snap, termTree, packedTermIndex) {
+    return encodeFrozenSnapshotMsv5Async(snap, termTree, packedTermIndex);
+}
+
+const LEGACY_MAGICS = new Set(['MSv1', 'MSv2', 'MSv3', 'MSv4']);
+/** Decode a frozen binary snapshot buffer. */
+function decodeFrozenSnapshot(buf) {
+    assertBufferLength(buf, 8);
+    const magic = buf.toString('ascii', 0, 4);
+    const version = buf.readUInt16LE(4);
+    if (isMsv5Buffer(buf) && version === 5) {
+        return decodeFrozenSnapshotMsv5(buf);
+    }
+    if (LEGACY_MAGICS.has(magic)) {
+        throw invalidFrozenIndex('Unsupported frozen binary snapshot; re-build with saveBinarySync() or from lucaong JSON');
+    }
+    throw invalidFrozenIndex('Unsupported frozen binary snapshot');
+}
+/** Async frozen snapshot decode (streaming zstd). */
+async function decodeFrozenSnapshotAsync(buf) {
+    assertBufferLength(buf, 8);
+    const version = buf.readUInt16LE(4);
+    if (isMsv5Buffer(buf) && version === 5) {
+        return decodeFrozenSnapshotMsv5Async(buf);
+    }
+    return decodeFrozenSnapshot(buf);
+}
+
+function getOrCreateTermIndex(state, index, term) {
+    const existing = index.get(term);
+    if (existing != null)
+        return existing;
+    const ti = state.terms.length;
+    state.terms.push(term);
+    index.set(term, ti);
+    return ti;
+}
+function appendPosting(state, termIndex, fieldId, docId, freq) {
+    const slot = termIndex * state.fieldCount + fieldId;
+    let docIds = state.postingsDocIds[slot];
+    if (docIds == null) {
+        docIds = [];
+        state.postingsDocIds[slot] = docIds;
+        state.postingsFreqs[slot] = [];
+    }
+    docIds.push(docId);
+    state.postingsFreqs[slot].push(freq);
+    const v = clampFreq(freq);
+    if (v > state.maxFreq)
+        state.maxFreq = v;
+    state.totalPostings++;
+}
+function finalizeFlatPostings(state, nextId) {
+    return materializeFrozenPostingsFromBuilder({
+        fieldCount: state.fieldCount,
+        termCount: state.terms.length,
+        postingsDocIds: state.postingsDocIds,
+        postingsFreqs: state.postingsFreqs,
+        totalPostings: state.totalPostings,
+        maxFreq: state.maxFreq,
+    }, nextId);
+}
+/** Incremental builder for {@link FrozenMiniSearch} without materializing a full `documents[]` array. */
+class FrozenIndexBuilder {
+    constructor(options, hints) {
+        this._options = resolveIndexingOptions(options);
+        this._fieldIds = buildFieldIds(this._options.fields);
+        this._fieldCount = this._options.fields.length;
+        this._index = new SearchableMap();
+        this._terms = [];
+        this._postingsDocIds = [];
+        this._postingsFreqs = [];
+        this._avgFieldLength = [];
+        this._seenIds = new Set();
+        this._nextId = 0;
+        this._frozen = false;
+        const estimated = hints === null || hints === void 0 ? void 0 : hints.estimatedDocumentCount;
+        if (estimated != null && estimated > 0) {
+            this._externalIds = new Array(estimated);
+            this._storedFields = new Array(estimated);
+            this._fieldLengthData = new Array(estimated * this._fieldCount).fill(0);
+        }
+        else {
+            this._externalIds = [];
+            this._storedFields = [];
+            this._fieldLengthData = [];
+        }
+        this._postingsState = {
+            fieldCount: this._fieldCount,
+            terms: this._terms,
+            postingsDocIds: this._postingsDocIds,
+            postingsFreqs: this._postingsFreqs,
+            totalPostings: 0,
+            maxFreq: 0,
+        };
+    }
+    /** Number of documents indexed so far (not yet frozen). */
+    get documentCount() {
+        return this._nextId;
+    }
+    add(document) {
+        if (this._frozen) {
+            throw new Error('FrozenIndexBuilder: cannot add after freezeParams()');
+        }
+        const { extractField, stringifyField, tokenize, processTerm, fields, idField, storeFields } = this._options;
+        const id = extractField(document, idField);
+        if (id == null) {
+            throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
+        }
+        if (this._seenIds.has(id)) {
+            throw new Error(`MiniSearch: duplicate ID ${id}`);
+        }
+        this._seenIds.add(id);
+        const shortId = this._nextId++;
+        this._externalIds[shortId] = id;
+        this._storedFields[shortId] = saveStoredFieldsForDocument(storeFields, extractField, document);
+        const documentCount = shortId + 1;
+        for (const field of fields) {
+            const fieldValue = extractField(document, field);
+            if (fieldValue == null)
+                continue;
+            const tokens = tokenize(stringifyField(fieldValue, field), field);
+            const fieldId = this._fieldIds[field];
+            const uniqueTerms = new Set(tokens).size;
+            const localFreqs = collectFieldTermFreqs(tokens, field, processTerm);
+            this._fieldLengthData[shortId * this._fieldCount + fieldId] = uniqueTerms;
+            updateAvgFieldLength(this._avgFieldLength, fieldId, documentCount - 1, uniqueTerms);
+            for (const [term, freq] of localFreqs) {
+                const ti = getOrCreateTermIndex(this._postingsState, this._index, term);
+                appendPosting(this._postingsState, ti, fieldId, shortId, freq);
+            }
+        }
+    }
+    /**
+     * Adds all the given documents to the index.
+     *
+     * @param documents  An array of documents to be indexed
+     */
+    addAll(documents) {
+        for (const document of documents)
+            this.add(document);
+    }
+    /**
+     * Adds all the given documents to the index asynchronously.
+     *
+     * Returns a promise that resolves (to `undefined`) when the indexing is done.
+     * This method is useful when indexing many documents, to avoid blocking the main
+     * thread. The indexing is performed asynchronously and in chunks. Finalize with
+     * {@link freezeFrozenIndexBuilder} when done.
+     *
+     * @param documents  An array of documents to be indexed
+     * @param options  Configuration options
+     * @return A promise resolving to `undefined` when the indexing is done
+     */
+    addAllAsync(documents, options = {}) {
+        const { chunkSize = 10 } = options;
+        if (!Number.isInteger(chunkSize) || chunkSize < 1) {
+            throw new Error('MiniSearch: chunkSize must be a positive integer');
+        }
+        const acc = { chunk: [], promise: Promise.resolve() };
+        const { chunk, promise } = documents.reduce(({ chunk, promise }, document, i) => {
+            chunk.push(document);
+            if ((i + 1) % chunkSize === 0) {
+                return {
+                    chunk: [],
+                    promise: promise
+                        .then(() => new Promise(resolve => setTimeout(resolve, 0)))
+                        .then(() => this.addAll(chunk)),
+                };
+            }
+            else {
+                return { chunk, promise };
+            }
+        }, acc);
+        return promise.then(() => this.addAll(chunk));
+    }
+    /**
+     * Finalize this builder into assembly params. Call {@link assembleFrozen} or
+     * {@link freezeFrozenIndexBuilder} to obtain a {@link FrozenMiniSearch} instance.
+     */
+    freezeParams() {
+        var _a;
+        if (this._frozen) {
+            throw new Error('FrozenIndexBuilder: freezeParams() already called');
+        }
+        this._frozen = true;
+        const documentCount = this._nextId;
+        const postings = finalizeFlatPostings(this._postingsState, documentCount);
+        const avgFieldLength = new Float32Array(this._fieldCount);
+        for (let f = 0; f < this._fieldCount; f++) {
+            avgFieldLength[f] = (_a = this._avgFieldLength[f]) !== null && _a !== void 0 ? _a : 0;
+        }
+        this._fieldLengthData.length = documentCount * this._fieldCount;
+        const externalIds = this._externalIds.length > documentCount
+            ? this._externalIds.slice(0, documentCount)
+            : this._externalIds;
+        const storedFields = this._storedFields.length > documentCount
+            ? this._storedFields.slice(0, documentCount)
+            : this._storedFields;
+        const idLookup = createIdToShortIdLookup(externalIds, documentCount);
+        // Incremental builder: numeric radix leaves + build-time terms[] for postings.
+        // freezeFromMiniSearch packs Map leaves in one radix pass (no resident terms[]).
+        return {
+            options: this._options,
+            documentCount,
+            nextId: documentCount,
+            fieldIds: this._fieldIds,
+            fieldCount: this._fieldCount,
+            externalIds,
+            idLookup,
+            storedFields,
+            fieldLengthMatrix: materializeFieldLengthMatrix(this._fieldLengthData, documentCount * this._fieldCount),
+            avgFieldLength,
+            index: fromRadixTree(this._index.radixTree, this._terms.length),
+            termCount: this._terms.length,
+            postings,
+        };
+    }
+}
+/** Create an incremental builder for {@link FrozenMiniSearch}. */
+function createFrozenIndexBuilder(options, hints) {
+    return new FrozenIndexBuilder(options, hints);
+}
+function buildFrozenParamsFromDocuments(documents, options) {
+    const builder = createFrozenIndexBuilder(options, {
+        estimatedDocumentCount: documents.length,
+    });
+    builder.addAll(documents);
+    return builder.freezeParams();
+}
+
+/**
+ * Internal AND / AND_NOT gate thresholds (not exported from the public package entry).
+ */
+const DEFAULT_AND_GATE_LIMITS = {
+    maxAbsolute: 5000,
+    maxFraction: 0.1,
+};
+function resolveGateMaxSize(documentCount, limits = DEFAULT_AND_GATE_LIMITS) {
+    return Math.min(limits.maxAbsolute, Math.max(100, Math.floor(documentCount * limits.maxFraction)));
+}
+function gateIsSelectiveEnough(gateSize, documentCount, limits = DEFAULT_AND_GATE_LIMITS) {
+    if (gateSize === 0)
+        return true;
+    return gateSize <= resolveGateMaxSize(documentCount, limits);
+}
+
+function useGatedEvaluation(run, branchCount, operator, hasWildcard) {
+    return shouldUseGatedEvaluation(branchCount, operator, hasWildcard);
+}
+function docIdsFromResult(result) {
+    return new Set(result.keys());
+}
+function isQueryCombination(query) {
+    return typeof query === 'object'
+        && query != null
+        && 'queries' in query
+        && Array.isArray(query.queries);
+}
+function combinationHasWildcard(query) {
+    return query.queries.some(q => isWildcardQuery(q) || (typeof q === 'object' && q != null && 'queries' in q && combinationHasWildcard(q)));
+}
+function isGatedCombinationOperator(operator) {
+    const op = operator.toLowerCase();
+    return op === 'and' || op === 'and_not';
+}
+function shouldUseGatedEvaluation(branchCount, operator, hasWildcard) {
+    if (hasWildcard)
+        return false;
+    if (branchCount <= 1)
+        return false;
+    return isGatedCombinationOperator(operator);
+}
+function maxFuzzyDistance(query, maxFuzzy) {
+    if (!query.fuzzy)
+        return 0;
+    const fuzzy = (query.fuzzy === true) ? 0.2 : query.fuzzy;
+    return fuzzy < 1
+        ? Math.min(maxFuzzy, Math.round(query.term.length * fuzzy))
+        : fuzzy;
+}
+function normalizeStringQuery(query, searchOptions, params) {
+    const options = {
+        tokenize: params.tokenize,
+        processTerm: params.processTerm,
+        ...params.globalSearchOptions,
+        ...searchOptions,
+    };
+    const terms = options.tokenize(query)
+        .flatMap((term) => options.processTerm(term))
+        .filter(term => !!term);
+    return {
+        options,
+        specs: terms.map(termToQuerySpec(options)),
+        operator: options.combineWith,
+    };
+}
+function lazyIndexedTerm(indexView, termIndex) {
+    return { kind: 'lazy', resolve: () => indexView.resolveTermByIndex(termIndex) };
+}
+function visitQuerySpecForScoring(query, options, params, visit) {
+    const { indexView } = params;
+    const { weights, maxFuzzy } = options;
+    const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights };
+    const maxDistance = maxFuzzyDistance(query, maxFuzzy);
+    const exactTi = indexView.resolveTermIndex(query.term);
+    visit(exactTi == null ? undefined : indexView.fieldTermData(exactTi), query.term, 1);
+    const seenPrefix = new Set();
+    if (query.prefix) {
+        for (const { termIndex, length } of indexView.getPrefixMatchesByIndex(query.term)) {
+            const distance = length - query.term.length;
+            if (!distance)
+                continue;
+            seenPrefix.add(termIndex);
+            visit(indexView.fieldTermData(termIndex), lazyIndexedTerm(indexView, termIndex), prefixWeight * length / (length + 0.3 * distance));
+        }
+    }
+    if (!maxDistance)
+        return;
+    for (const { termIndex, length, distance } of indexView.getFuzzyMatchesByIndex(query.term, maxDistance)) {
+        if (!distance || seenPrefix.has(termIndex))
+            continue;
+        visit(indexView.fieldTermData(termIndex), lazyIndexedTerm(indexView, termIndex), fuzzyWeight * length / (length + distance));
+    }
+}
+function executeQuerySpecInternal(query, searchOptions, params, allowedDocs) {
+    const options = { ...params.globalSearchOptions, ...searchOptions };
+    const fieldBoosts = fieldBoostsForQuery(options, params.fields);
+    const termOptions = allowedDocs == null ? undefined : { allowedDocs };
+    const results = new Map();
+    visitQuerySpecForScoring(query, options, params, (data, derivedTerm, termWeight) => {
+        aggregateTerm(query.term, derivedTerm, termWeight, query.termBoost, data, fieldBoosts, params.aggregateContext, options.boostDocument, options.bm25, results, termOptions);
+    });
+    return results;
+}
+function collectDocIdsForQuerySpec(query, searchOptions, params, allowedDocs) {
+    const options = { ...params.globalSearchOptions, ...searchOptions };
+    const fieldBoosts = fieldBoostsForQuery(options, params.fields);
+    const docIds = new Set();
+    const { indexView, aggregateContext } = params;
+    const maxDistance = maxFuzzyDistance(query, options.maxFuzzy);
+    const exactTi = indexView.resolveTermIndex(query.term);
+    if (exactTi != null) {
+        indexView.collectDocIds(exactTi, fieldBoosts, aggregateContext, docIds, allowedDocs);
+    }
+    const seenPrefix = new Set();
+    if (query.prefix) {
+        for (const { termIndex, length } of indexView.getPrefixMatchesByIndex(query.term)) {
+            const distance = length - query.term.length;
+            if (!distance)
+                continue;
+            seenPrefix.add(termIndex);
+            indexView.collectDocIds(termIndex, fieldBoosts, aggregateContext, docIds, allowedDocs);
+        }
+    }
+    if (maxDistance) {
+        for (const { termIndex, distance } of indexView.getFuzzyMatchesByIndex(query.term, maxDistance)) {
+            if (!distance || seenPrefix.has(termIndex))
+                continue;
+            indexView.collectDocIds(termIndex, fieldBoosts, aggregateContext, docIds, allowedDocs);
+        }
+    }
+    return docIds;
+}
+function intersectDocIdsInPlace(docIds, branchDocIds) {
+    for (const docId of docIds) {
+        if (!branchDocIds.has(docId))
+            docIds.delete(docId);
+    }
+}
+function subtractDocIdsInPlace(docIds, excludedDocIds) {
+    for (const docId of excludedDocIds)
+        docIds.delete(docId);
+}
+function subtractDocIdsFromResult(result, excludedDocIds) {
+    for (const docId of excludedDocIds)
+        result.delete(docId);
+}
+function collectCombinedDocIds(branches, operator, collectBranch, allowedDocs) {
+    if (branches.length === 0)
+        return new Set();
+    const op = operator.toLowerCase();
+    if (op === 'or') {
+        const docIds = new Set();
+        for (const branch of branches) {
+            for (const docId of collectBranch(branch, allowedDocs)) {
+                docIds.add(docId);
+            }
+        }
+        return docIds;
+    }
+    const docIds = collectBranch(branches[0], allowedDocs);
+    if (op === 'and') {
+        for (let i = 1; i < branches.length; i++) {
+            intersectDocIdsInPlace(docIds, collectBranch(branches[i], docIds));
+        }
+        return docIds;
+    }
+    if (op === 'and_not') {
+        for (let i = 1; i < branches.length; i++) {
+            subtractDocIdsInPlace(docIds, collectBranch(branches[i], docIds));
+        }
+        return docIds;
+    }
+    throw new Error(`Invalid combination operator: ${operator}`);
+}
+/**
+ * AND: score every branch (with optional docId gate on later branches), then intersect scores.
+ * AND_NOT: score the positive branch only; negated branches are collected as docId sets and
+ * subtracted without scoring (avoids term materialization on excluded branches).
+ */
+function executeCombinedBranches(branches, operator, params, executeBranch, collectBranch, allowedDocs, run) {
+    if (branches.length === 0)
+        return new Map();
+    const op = operator.toLowerCase();
+    if (op === 'or') {
+        return combineResults(branches.map(branch => executeBranch(branch, allowedDocs)), operator);
+    }
+    let result = executeBranch(branches[0], allowedDocs);
+    let gate = docIdsFromResult(result);
+    if (op === 'and') {
+        const limits = void 0 ;
+        const documentCount = params.aggregateContext.documentCount;
+        for (let i = 1; i < branches.length; i++) {
+            const selective = gateIsSelectiveEnough(gate.size, documentCount, limits);
+            const branchAllowed = selective ? gate : allowedDocs;
+            result = combineResults([result, executeBranch(branches[i], branchAllowed)], AND);
+            gate = docIdsFromResult(result);
+        }
+        return result;
+    }
+    if (op === 'and_not') {
+        for (let i = 1; i < branches.length; i++) {
+            subtractDocIdsFromResult(result, collectBranch(branches[i], gate));
+            gate = docIdsFromResult(result);
+        }
+        return result;
+    }
+    throw new Error(`Invalid combination operator: ${operator}`);
+}
+/** Query adapter for packed frozen term indexes. */
+function createFrozenQueryIndexView(index, layout, flyweight, forEachActiveDoc) {
+    return {
+        resolveTermIndex(term) {
+            const ti = index.get(term);
+            return ti == null ? undefined : ti;
+        },
+        fieldTermData(termIndex) {
+            return flyweight.bind(termIndex);
+        },
+        collectDocIds(termIndex, fieldBoosts, context, docIds, allowedDocs) {
+            collectDocIdsFromFrozenLayout(layout, termIndex, fieldBoosts, context, docIds, allowedDocs);
+        },
+        getTermData(term) {
+            const ti = index.get(term);
+            return ti == null ? undefined : flyweight.bind(ti);
+        },
+        *getPrefixMatchesByIndex(term) {
+            yield* index.prefixRefs(term);
+        },
+        *getFuzzyMatchesByIndex(term, maxDistance) {
+            yield* index.fuzzyRefs(term, maxDistance);
+        },
+        resolveTermByIndex(termIndex) {
+            return index.termByIndex(termIndex);
+        },
+        forEachActiveDoc,
+    };
+}
+function collectDocIdsForQueryInternal(query, searchOptions, params, allowedDocs) {
+    var _a, _b;
+    if (isWildcardQuery(query)) {
+        const docIds = new Set();
+        params.indexView.forEachActiveDoc((docId) => {
+            if (allowedDocs != null && !allowedDocs.has(docId))
+                return;
+            docIds.add(docId);
+        });
+        return docIds;
+    }
+    if (isQueryCombination(query)) {
+        const options = { ...searchOptions, ...query, queries: undefined };
+        const operator = ((_b = (_a = query.combineWith) !== null && _a !== void 0 ? _a : options.combineWith) !== null && _b !== void 0 ? _b : params.globalSearchOptions.combineWith);
+        return collectCombinedDocIds(query.queries, operator, (branch, branchAllowed) => collectDocIdsForQueryInternal(branch, options, params, branchAllowed), allowedDocs);
+    }
+    if (typeof query !== 'string') {
+        throw new Error('FrozenMiniSearch: invalid query');
+    }
+    const { options, specs, operator } = normalizeStringQuery(query, searchOptions, params);
+    const combineWith = (operator !== null && operator !== void 0 ? operator : params.globalSearchOptions.combineWith);
+    if (specs.length <= 1) {
+        return specs.length === 1
+            ? collectDocIdsForQuerySpec(specs[0], options, params, allowedDocs)
+            : new Set();
+    }
+    return collectCombinedDocIds(specs, combineWith, (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, options, params, branchAllowed), allowedDocs);
+}
+function executeWildcardQuery(searchOptions, params) {
+    const results = new Map();
+    const options = { ...params.globalSearchOptions, ...searchOptions };
+    const { boostDocument } = options;
+    params.indexView.forEachActiveDoc((shortId, id, storedFields) => {
+        const score = boostDocument ? boostDocument(id, '', storedFields) : 1;
+        results.set(shortId, { score, terms: [], match: {} });
+    });
+    return results;
+}
+function executeQueryInternal(query, searchOptions, params, allowedDocs, run) {
+    var _a, _b;
+    if (isWildcardQuery(query)) {
+        return executeWildcardQuery(searchOptions, params);
+    }
+    if (isQueryCombination(query)) {
+        // Spread inherits parent combineWith into child branches (lucaong 7.2 behavior).
+        const options = { ...searchOptions, ...query, queries: undefined };
+        const operator = ((_b = (_a = query.combineWith) !== null && _a !== void 0 ? _a : options.combineWith) !== null && _b !== void 0 ? _b : params.globalSearchOptions.combineWith);
+        if (useGatedEvaluation(run, query.queries.length, operator, combinationHasWildcard(query))) {
+            return executeCombinedBranches(query.queries, operator, params, (branch, branchAllowed) => executeQueryInternal(branch, options, params, branchAllowed, run), (branch, branchAllowed) => collectDocIdsForQueryInternal(branch, options, params, branchAllowed), allowedDocs);
+        }
+        const results = query.queries.map(subquery => executeQueryInternal(subquery, options, params, allowedDocs, run));
+        return combineResults(results, operator);
+    }
+    if (typeof query !== 'string') {
+        throw new Error('FrozenMiniSearch: invalid query');
+    }
+    const { options, specs, operator } = normalizeStringQuery(query, searchOptions, params);
+    const combineWith = (operator !== null && operator !== void 0 ? operator : params.globalSearchOptions.combineWith);
+    if (useGatedEvaluation(run, specs.length, combineWith, false)) {
+        return executeCombinedBranches(specs, combineWith, params, (spec, branchAllowed) => executeQuerySpecInternal(spec, options, params, branchAllowed), (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, options, params, branchAllowed), allowedDocs);
+    }
+    const results = specs.map(spec => executeQuerySpecInternal(spec, options, params, allowedDocs));
+    return combineResults(results, combineWith);
+}
+function executeQuery(query, searchOptions, params) {
+    return executeQueryInternal(query, searchOptions, params);
+}
+
+/** Aggregate search hits into ranked phrase suggestions. */
+function suggestFromSearchResults(hits) {
+    const suggestions = new Map();
+    for (const { score, terms } of hits) {
+        const phrase = terms.join(' ');
+        const suggestion = suggestions.get(phrase);
+        if (suggestion != null) {
+            suggestion.score += score;
+            suggestion.count += 1;
+        }
+        else {
+            suggestions.set(phrase, { score, terms, count: 1 });
+        }
+    }
+    const results = [];
+    for (const [suggestion, { score, terms, count }] of suggestions) {
+        results.push({ suggestion, terms, score: score / count });
+    }
+    results.sort(byScore);
+    return results;
+}
+/** Run a search and turn hits into suggestions (shared by mutable and frozen indexes). */
+function autoSuggestFromSearch(search, queryString, options = {}) {
+    return suggestFromSearchResults(search(queryString, options));
+}
+
+function ownedIndexArray(arr) {
+    if (arr instanceof Uint8Array)
+        return new Uint8Array(arr);
+    if (arr instanceof Uint16Array)
+        return new Uint16Array(arr);
+    return new Uint32Array(arr);
+}
+function ownedFieldLengthMatrix(matrix) {
+    return ownedIndexArray(matrix);
+}
+function ownedPackedRadixTree(index) {
+    return PackedRadixTree.fromData({
+        size: index.size,
+        nodeCount: index.nodeCount,
+        edgeCount: index.edgeCount,
+        labelHeap: index.labelHeap,
+        nodeEdgeOffset: ownedIndexArray(index.nodeEdgeOffset),
+        nodeValue: ownedIndexArray(index.nodeValue),
+        nodeLeafOrder: ownedIndexArray(index.nodeLeafOrder),
+        edgeLabelStart: ownedIndexArray(index.edgeLabelStart),
+        edgeLabelLength: ownedIndexArray(index.edgeLabelLength),
+        edgeChild: ownedIndexArray(index.edgeChild),
+    });
+}
+function ownedPostingsLayout(postings) {
+    const allDocIds = postings.docIdWidth === 16
+        ? new Uint16Array(postings.allDocIds)
+        : new Uint32Array(postings.allDocIds);
+    const allFreqs = postings.allFreqs instanceof Uint8Array
+        ? new Uint8Array(postings.allFreqs)
+        : new Uint16Array(postings.allFreqs);
+    if (postings.layout === 'dense') {
+        return {
+            ...postings,
+            allDocIds,
+            allFreqs,
+            denseOffsets: new Uint32Array(postings.denseOffsets),
+            denseLengths: new Uint32Array(postings.denseLengths),
+        };
+    }
+    const sparseFieldIds = postings.sparseFieldIdWidth === 16
+        ? new Uint16Array(postings.sparseFieldIds)
+        : new Uint8Array(postings.sparseFieldIds);
+    return {
+        ...postings,
+        allDocIds,
+        allFreqs,
+        sparseTermStarts: new Uint32Array(postings.sparseTermStarts),
+        sparseFieldIds,
+        sparseOffsets: new Uint32Array(postings.sparseOffsets),
+        sparseLengths: new Uint32Array(postings.sparseLengths),
+    };
+}
+function shallowCopyOptions(options) {
+    return {
+        ...options,
+        fields: [...options.fields],
+        searchOptions: { ...options.searchOptions },
+        autoSuggestOptions: { ...options.autoSuggestOptions },
+    };
+}
+function shallowCopyJsSnapshotFields(params) {
+    return {
+        fieldIds: { ...params.fieldIds },
+        options: shallowCopyOptions(params.options),
+        storedFields: params.storedFields.slice(),
+    };
+}
+/**
+ * Ensure {@link FrozenMiniSearch} owns its snapshot data (no aliases on source MiniSearch,
+ * no TypedArray views on wire buffers after binary load).
+ */
+function materializeOwnedSnapshot(params, mode) {
+    if (mode === 'trusted-build') {
+        return params;
+    }
+    if (mode === 'minisearch-json') {
+        return { ...params, ...shallowCopyJsSnapshotFields(params) };
+    }
+    return {
+        ...params,
+        index: ownedPackedRadixTree(params.index),
+        postings: ownedPostingsLayout(params.postings),
+        fieldLengthMatrix: ownedFieldLengthMatrix(params.fieldLengthMatrix),
+        avgFieldLength: new Float32Array(params.avgFieldLength),
+    };
+}
+
+function frozenMemoryBreakdown(frozen) {
+    return frozen.memoryBreakdown();
+}
+function assertFieldsMatchSnapshot(optionsFields, snapFieldIds) {
+    const snapNames = Object.keys(snapFieldIds).sort();
+    const optNames = [...optionsFields].sort();
+    if (snapNames.length !== optNames.length || snapNames.some((name, i) => name !== optNames[i])) {
+        throw new Error(`FrozenMiniSearch: option "fields" must match the indexed fields exactly (expected: ${snapNames.join(', ')})`);
+    }
+}
+function assembleFrozenInternal(params, trustedSource, ownershipMode) {
+    const owned = materializeOwnedSnapshot(params, ownershipMode);
+    const termCount = owned.termCount;
+    if (owned.fieldLengthMatrix.length !== owned.nextId * owned.fieldCount) {
+        throw new Error('FrozenMiniSearch: fieldLengthMatrix size mismatch');
+    }
+    if (owned.avgFieldLength.length !== owned.fieldCount) {
+        throw new Error('FrozenMiniSearch: avgFieldLength size mismatch');
+    }
+    if (!trustedSource) {
+        validateFrozenPostingsLayout(owned.postings, owned.documentCount, owned.nextId);
+        validateFrozenTermIndexLeaves(owned.index, termCount);
+    }
+    return new FrozenMiniSearch(owned);
+}
+/** Trusted build paths only (same package); skips O(postings) layout checks. */
+function assembleFrozenTrusted(params, ownershipMode = 'trusted-build') {
+    return assembleFrozenInternal(params, true, ownershipMode);
+}
+/** Instantiate {@link FrozenMiniSearch} from pre-built flat index parts (full validation). */
+function assembleFrozen(params) {
+    return assembleFrozenInternal(params, false, 'binary-load');
+}
+function buildFrozenFromDocuments(documents, options) {
+    return assembleFrozenTrusted(buildFrozenParamsFromDocuments(documents, options));
+}
+/** Finalize a {@link FrozenIndexBuilder} into a read-only index. */
+function freezeFrozenIndexBuilder(builder) {
+    return assembleFrozenTrusted(builder.freezeParams());
+}
+class FrozenMiniSearch {
+    constructor(params) {
+        this._options = params.options;
+        this._documentCount = params.documentCount;
+        this._nextId = params.nextId;
+        this._externalIds = params.externalIds;
+        this._idLookup = params.idLookup;
+        this._fieldIds = params.fieldIds;
+        this._fieldCount = params.fieldCount;
+        this._fieldLengthMatrix = params.fieldLengthMatrix;
+        this._avgFieldLength = params.avgFieldLength;
+        this._storedFields = params.storedFields;
+        this._index = params.index;
+        this._termCount = params.termCount;
+        this._postings = params.postings;
+        this._fieldTermFlyweight = createFrozenFieldTermFlyweight(this._postings);
+        this._aggregateContext = {
+            documentCount: this._documentCount,
+            avgFieldLength: this._avgFieldLength,
+            fieldIds: this._fieldIds,
+            getFieldLength: (docId, fieldId) => this.getFieldLength(docId, fieldId),
+            getExternalId: docId => this._externalIds[docId],
+            getStoredFields: docId => this._storedFields[docId],
+        };
+        this._queryEngineParams = {
+            fields: this._options.fields,
+            globalSearchOptions: this._options.searchOptions,
+            tokenize: this._options.tokenize,
+            processTerm: this._options.processTerm,
+            indexView: createFrozenQueryIndexView(this._index, this._postings, this._fieldTermFlyweight, (callback) => {
+                for (let shortId = 0; shortId < this._nextId; shortId++) {
+                    const id = this._externalIds[shortId];
+                    if (id === undefined)
+                        continue;
+                    callback(shortId, id, this._storedFields[shortId]);
+                }
+            }),
+            aggregateContext: this._aggregateContext,
+        };
+    }
+    get documentCount() { return this._documentCount; }
+    get termCount() { return this._termCount; }
+    memoryBreakdown() {
+        const termCount = this.termCount;
+        const postingsStats = postingsTypedBytes(this._postings);
+        let storedJson = 0;
+        for (const row of this._storedFields) {
+            if (row != null)
+                storedJson += JSON.stringify(row).length;
+        }
+        const radixEst = this._index.packedByteLength();
+        const idMapBytes = this._idLookup.mode === 'lazy-map' ? this._idLookup.mapEntryCount * 32 : 0;
+        const estimatedStructuredBytes = postingsStats.totalTypedBytes
+            + this._fieldLengthMatrix.byteLength
+            + this._avgFieldLength.byteLength
+            + radixEst
+            + storedJson
+            + idMapBytes;
+        return {
+            termCount,
+            documentCount: this._documentCount,
+            nextId: this._nextId,
+            postings: {
+                slotCount: postingsStats.slotCount,
+                layout: this._postings.layout,
+                docIdWidth: this._postings.docIdWidth,
+                allDocIdsBytes: postingsStats.allDocIdsBytes,
+                allFreqsBytes: postingsStats.allFreqsBytes,
+                offsetsBytes: postingsStats.offsetsBytes,
+                lengthsBytes: postingsStats.lengthsBytes,
+                totalTypedBytes: postingsStats.totalTypedBytes,
+            },
+            radixTree: {
+                nodeCount: this._index.packedNodeCount(),
+                edgeCount: this._index.packedEdgeCount(),
+                estimatedBytes: radixEst,
+            },
+            documents: {
+                externalIdsSlots: this._externalIds.length,
+                storedFieldsSlots: this._storedFields.length,
+                idLookupMode: this._idLookup.mode,
+                idToShortIdEntries: this._idLookup.mapEntryCount,
+                fieldLengthMatrixBytes: this._fieldLengthMatrix.byteLength,
+                avgFieldLengthBytes: this._avgFieldLength.byteLength,
+                storedFieldsJsonBytes: storedJson,
+            },
+            estimatedStructuredBytes,
+        };
+    }
+    has(id) {
+        return this._idLookup.has(id);
+    }
+    getStoredFields(id) {
+        const shortId = this._idLookup.get(id);
+        return shortId == null ? undefined : this._storedFields[shortId];
+    }
+    search(query, searchOptions = {}) {
+        return finalizeRawSearchResults(this.executeQuery(query, searchOptions), query, searchOptions, this._options.searchOptions, docId => this._externalIds[docId], docId => this._storedFields[docId]);
+    }
+    autoSuggest(queryString, options = {}) {
+        const merged = { ...this._options.autoSuggestOptions, ...options };
+        return autoSuggestFromSearch((q, o) => this.search(q, o), queryString, merged);
+    }
+    /** Serialize this index as a frozen binary snapshot (synchronous). */
+    saveBinarySync() {
+        return encodeFrozenSnapshot({
+            documentCount: this._documentCount,
+            nextId: this._nextId,
+            fieldIds: this._fieldIds,
+            fieldCount: this._fieldCount,
+            fieldNames: fieldNamesFromFieldIds(this._fieldIds),
+            avgFieldLength: this._avgFieldLength,
+            externalIds: this._externalIds,
+            storedFields: this._storedFields,
+            fieldLengthMatrix: fieldLengthMatrixForWire(this._fieldLengthMatrix),
+            treeShape: [],
+            postings: this._postings,
+        }, undefined, this._index);
+    }
+    /** Non-blocking zstd compression; same output as {@link saveBinarySync}. */
+    async saveBinaryAsync() {
+        return encodeFrozenSnapshotAsync({
+            documentCount: this._documentCount,
+            nextId: this._nextId,
+            fieldIds: this._fieldIds,
+            fieldCount: this._fieldCount,
+            fieldNames: fieldNamesFromFieldIds(this._fieldIds),
+            avgFieldLength: this._avgFieldLength,
+            externalIds: this._externalIds,
+            storedFields: this._storedFields,
+            fieldLengthMatrix: fieldLengthMatrixForWire(this._fieldLengthMatrix),
+            treeShape: [],
+            postings: this._postings,
+        }, undefined, this._index);
+    }
+    /** Load a frozen binary snapshot. */
+    static loadBinarySync(buffer, options = {}) {
+        const snap = decodeFrozenSnapshot(buffer);
+        return FrozenMiniSearch.fromBinarySnapshot(snap, options);
+    }
+    /** Load a frozen binary snapshot with streaming zstd decompression (bounded memory). */
+    static async loadBinaryAsync(buffer, options = {}) {
+        const snap = await decodeFrozenSnapshotAsync(buffer);
+        return FrozenMiniSearch.fromBinarySnapshot(snap, options);
+    }
+    static fromBinarySnapshot(snap, options) {
+        var _a, _b;
+        const snapshotFields = (_a = snap.fieldNames) !== null && _a !== void 0 ? _a : fieldNamesFromFieldIds(snap.fieldIds);
+        if (options.fields != null) {
+            assertFieldsMatchSnapshot(options.fields, snap.fieldIds);
+        }
+        const opts = {
+            ...defaultFrozenLoadOptions,
+            ...options,
+            fields: (_b = options.fields) !== null && _b !== void 0 ? _b : snapshotFields,
+            searchOptions: {
+                ...defaultSearchOptions,
+                ...(options.searchOptions || {}),
+            },
+            autoSuggestOptions: { ...defaultAutoSuggestOptions, ...(options.autoSuggestOptions || {}) },
+        };
+        const index = snap.packedTermIndex;
+        if (index == null) {
+            throw new Error('FrozenMiniSearch: binary snapshot missing packed term index');
+        }
+        const idLookup = createIdToShortIdLookup(snap.externalIds, snap.nextId);
+        return assembleFrozen({
+            options: opts,
+            documentCount: snap.documentCount,
+            nextId: snap.nextId,
+            fieldIds: snap.fieldIds,
+            fieldCount: snap.fieldCount,
+            externalIds: snap.externalIds,
+            idLookup,
+            storedFields: snap.storedFields,
+            fieldLengthMatrix: snap.fieldLengthMatrix,
+            avgFieldLength: snap.avgFieldLength,
+            index,
+            termCount: snap.postings.termCount,
+            postings: snap.postings,
+        });
+    }
+    /** Build a read-only index in one pass from documents. */
+    static fromDocuments(documents, options) {
+        return buildFrozenFromDocuments(documents, options);
+    }
+    /**
+     * Convert a lucaong MiniSearch JSON snapshot (`toJSON` / `loadJSON` wire format) into a
+     * frozen index. No runtime dependency on the `minisearch` package.
+     */
+    static fromMiniSearchJson(json, options = {}) {
+        return FrozenMiniSearch.fromMiniSearchSnapshot(JSON.parse(json), options);
+    }
+    /**
+     * Same as {@link fromMiniSearchJson} with a pre-parsed snapshot object.
+     * `storedFields` are shallow-copied; callers must not mutate nested values
+     * after load if they intend to keep the index immutable.
+     */
+    static fromMiniSearchSnapshot(snapshot, options = {}) {
+        return assembleFrozenTrusted(buildFrozenAssembleParamsFromMiniSearchSnapshot(snapshot, options), 'minisearch-json');
+    }
+    /** Accepts any object exposing `toJSON()` in lucaong MiniSearch snapshot shape. */
+    static fromMiniSearch(source, options = {}) {
+        return FrozenMiniSearch.fromMiniSearchSnapshot(source.toJSON(), options);
+    }
+    /**
+     * Build a read-only index from an async stream of documents (e.g. CSV parser).
+     * For sync iterables, use {@link createFrozenIndexBuilder} with `for...of` instead.
+     *
+     * @param hints  Optional builder hints; `estimatedDocumentCount` pre-allocates
+     *   per-document arrays when the final document count is known upfront.
+     */
+    static async fromAsyncIterable(iterable, options, hints) {
+        const builder = createFrozenIndexBuilder(options, hints);
+        for await (const document of iterable) {
+            builder.add(document);
+        }
+        return freezeFrozenIndexBuilder(builder);
+    }
+    getFieldLength(docId, fieldId) {
+        var _a;
+        return (_a = this._fieldLengthMatrix[docId * this._fieldCount + fieldId]) !== null && _a !== void 0 ? _a : 0;
+    }
+    executeQuery(query, searchOptions = {}) {
+        return executeQuery(query, searchOptions, this._queryEngineParams);
+    }
+}
+FrozenMiniSearch.wildcard = WILDCARD_QUERY;
+
+exports.AND = AND;
+exports.AND_NOT = AND_NOT;
+exports.FrozenIndexBuilder = FrozenIndexBuilder;
+exports.OR = OR;
+exports.assembleFrozen = assembleFrozen;
+exports.buildFrozenFromDocuments = buildFrozenFromDocuments;
+exports.createFrozenIndexBuilder = createFrozenIndexBuilder;
+exports.default = FrozenMiniSearch;
+exports.freezeFrozenIndexBuilder = freezeFrozenIndexBuilder;
+exports.frozenMemoryBreakdown = frozenMemoryBreakdown;