@yoch/frozenminisearch 1.0.0 → 1.0.2

package/dist/es/index.js

@@ -1907,111 +1907,6 @@ function materializeFrozenPostings(params) {
         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;
@@ -2121,24 +2016,33 @@ function findSparseSlotByFieldId(fieldIds, start, end, fieldId) {
     }
     return -1;
 }
-/** Resolve one (termIndex, fieldId) posting run in flat buffers; shared by flyweight and docId collect. */
-function frozenPostingSlice(layout, termIndex, fieldId) {
+/** Reusable scratch for {@link resolvePostingSlice} (scoring is synchronous). */
+const postingSliceScratch = { offset: 0, length: 0 };
+/**
+ * Resolve one (termIndex, fieldId) posting run in flat buffers; writes into `out` without allocating.
+ * @returns false when the slot is empty or missing
+ */
+function resolvePostingSlice(layout, termIndex, fieldId, out) {
     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 };
+            return false;
+        out.offset = layout.denseOffsets[base];
+        out.length = len;
+        return true;
     }
     const start = layout.sparseTermStarts[termIndex];
     const end = layout.sparseTermStarts[termIndex + 1];
     const slot = findSparseSlotByFieldId(layout.sparseFieldIds, start, end, fieldId);
     if (slot < 0)
-        return undefined;
+        return false;
     const len = layout.sparseLengths[slot];
     if (len === 0)
-        return undefined;
-    return { offset: layout.sparseOffsets[slot], length: len };
+        return false;
+    out.offset = layout.sparseOffsets[slot];
+    out.length = len;
+    return true;
 }
 /**
  * One flyweight wrapper for the lifetime of a frozen index. Call {@link bind} before each
@@ -2154,10 +2058,9 @@ function createFrozenFieldTermFlyweight(layout) {
             return flyweight;
         },
         get(fieldId) {
-            const slice = frozenPostingSlice(layout, termIndex, fieldId);
-            if (slice == null)
+            if (!resolvePostingSlice(layout, termIndex, fieldId, postingSliceScratch))
                 return undefined;
-            return segment.rebind(slice.offset, slice.length);
+            return segment.rebind(postingSliceScratch.offset, postingSliceScratch.length);
         },
     };
     return flyweight;
@@ -2176,10 +2079,9 @@ function collectDocIdsFromFrozenSegment(allDocIds, offset, length, context, docI
 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)
+        if (!resolvePostingSlice(layout, termIndex, fieldIds[field], postingSliceScratch))
             continue;
-        collectDocIdsFromFrozenSegment(layout.allDocIds, slice.offset, slice.length, context, docIds, allowedDocs);
+        collectDocIdsFromFrozenSegment(layout.allDocIds, postingSliceScratch.offset, postingSliceScratch.length, context, docIds, allowedDocs);
     }
 }
 
@@ -2221,45 +2123,499 @@ function resolveIndexingOptions(options) {
         autoSuggestOptions: { ...defaultAutoSuggestOptions, ...(options.autoSuggestOptions || {}) },
     };
 }
-function buildFieldIds(fields) {
-    const fieldIds = {};
-    for (let i = 0; i < fields.length; i++) {
-        fieldIds[fields[i]] = i;
+function buildFieldIds(fields) {
+    const fieldIds = {};
+    for (let i = 0; i < fields.length; i++) {
+        fieldIds[fields[i]] = i;
+    }
+    return fieldIds;
+}
+function accumulateProcessedTerm(localFreqs, processedTerm) {
+    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);
+    }
+}
+/**
+ * Accumulate token frequencies for one document field into `localFreqs` (cleared first).
+ * Returns the number of distinct processed terms (replaces a separate `Set(tokens)` pass).
+ */
+function collectFieldTermFreqsInto(localFreqs, tokens, fieldName, processTerm) {
+    localFreqs.clear();
+    for (const term of tokens) {
+        accumulateProcessedTerm(localFreqs, processTerm(term, fieldName));
+    }
+    return localFreqs.size;
+}
+/** Global delimiter pattern for incremental `exec` (must not reuse {@link SPACE_OR_PUNCTUATION} — no `g` flag). */
+const DEFAULT_TOKENIZE_DELIMITERS = /[\n\r\p{Z}\p{P}]+/gu;
+const defaultTokenizeProbe = 'a b';
+const defaultTokenizeProbeField = 'f';
+const tokenizeBehaviorCache = new WeakMap();
+/**
+ * True when `tokenize` matches the library default (reference equality or split-equivalent
+ * on a fixed probe). Custom tokenizers that pass the probe but diverge on other inputs
+ * (e.g. leading delimiters) still take the fast path — use the default reference in prod.
+ */
+function isDefaultTokenize(tokenize) {
+    if (tokenize === defaultFrozenLoadOptions.tokenize)
+        return true;
+    const cached = tokenizeBehaviorCache.get(tokenize);
+    if (cached != null)
+        return cached;
+    const splitTokens = defaultTokenizeProbe.split(SPACE_OR_PUNCTUATION);
+    const customTokens = tokenize(defaultTokenizeProbe, defaultTokenizeProbeField);
+    const ok = splitTokens.length === customTokens.length
+        && splitTokens.every((t, i) => t === customTokens[i]);
+    tokenizeBehaviorCache.set(tokenize, ok);
+    return ok;
+}
+function forEachDefaultToken(text, onToken) {
+    if (text.length === 0) {
+        onToken('');
+        return;
+    }
+    let start = 0;
+    const re = DEFAULT_TOKENIZE_DELIMITERS;
+    re.lastIndex = 0;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        if (match.index > start) {
+            onToken(text.slice(start, match.index));
+        }
+        else if (match.index === start) {
+            onToken('');
+        }
+        start = match.index + match[0].length;
+    }
+    if (start < text.length) {
+        onToken(text.slice(start));
+    }
+    else if (start === 0) {
+        onToken(text);
+    }
+    else if (start === text.length) {
+        onToken('');
+    }
+}
+/** Default tokenizer into a reusable buffer (avoids `text.split()` array allocation). */
+function tokenizeDefaultInto(out, text) {
+    out.length = 0;
+    forEachDefaultToken(text, (token) => out.push(token));
+}
+/** Tokenize field text into `out` (reused). Fast path when `tokenize` is the library default. */
+function tokenizeFieldInto(out, tokenize, text, fieldName) {
+    if (isDefaultTokenize(tokenize)) {
+        tokenizeDefaultInto(out, text);
+        return;
+    }
+    const tokens = tokenize(text, fieldName);
+    out.length = 0;
+    out.push(...tokens);
+}
+function collectDefaultFieldTermFreqsInto(localFreqs, text, fieldName, processTerm) {
+    localFreqs.clear();
+    forEachDefaultToken(text, (token) => {
+        accumulateProcessedTerm(localFreqs, processTerm(token, fieldName));
+    });
+    return localFreqs.size;
+}
+/**
+ * Tokenize + accumulate field term frequencies in one pass when the default tokenizer is used.
+ * `tokenScratch` is only used for custom tokenizers (two-phase fallback).
+ */
+function collectFieldTermFreqsFromFieldInto(localFreqs, tokenScratch, tokenize, text, fieldName, processTerm) {
+    if (isDefaultTokenize(tokenize)) {
+        return collectDefaultFieldTermFreqsInto(localFreqs, text, fieldName, processTerm);
+    }
+    tokenizeFieldInto(tokenScratch, tokenize, text, fieldName);
+    return collectFieldTermFreqsInto(localFreqs, tokenScratch, fieldName, processTerm);
+}
+function updateAvgFieldLength(avgFieldLength, fieldId, count, length) {
+    const averageFieldLength = avgFieldLength[fieldId] || 0;
+    const totalFieldLength = (averageFieldLength * count) + length;
+    avgFieldLength[fieldId] = totalFieldLength / (count + 1);
+}
+
+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;
+}
+
+/**
+ * Runtime stored fields. Single store field → one column (no per-doc Record at rest).
+ * Wire format stays row JSON; encode/decode can skip intermediate row arrays when layout is known.
+ */
+function createStoredFieldsLayout(storeFields, capacity = 0) {
+    if (storeFields.length === 0)
+        return { kind: 'none' };
+    if (storeFields.length === 1) {
+        return { kind: 'single', field: storeFields[0], values: new Array(capacity) };
+    }
+    return { kind: 'multi', rows: new Array(capacity) };
+}
+function writeStoredField(layout, shortId, storeFields, extractField, document) {
+    if (layout.kind === 'none')
+        return;
+    if (layout.kind === 'single') {
+        layout.values[shortId] = extractField(document, layout.field);
+        return;
     }
-    return fieldIds;
+    const row = {};
+    for (const name of storeFields) {
+        const value = extractField(document, name);
+        if (value !== undefined)
+            row[name] = value;
+    }
+    layout.rows[shortId] = row;
 }
-/** 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);
+/** Materialize API/wire row for one document. */
+function readStoredFields(layout, shortId) {
+    if (layout.kind === 'none')
+        return undefined;
+    if (layout.kind === 'multi')
+        return layout.rows[shortId];
+    const value = layout.values[shortId];
+    if (value === undefined)
+        return {};
+    return { [layout.field]: value };
+}
+function resizeStoredFields(layout, length) {
+    if (layout.kind === 'none')
+        return layout;
+    if (layout.kind === 'single') {
+        return layout.values.length <= length
+            ? layout
+            : { kind: 'single', field: layout.field, values: layout.values.slice(0, length) };
+    }
+    return layout.rows.length <= length
+        ? layout
+        : { kind: 'multi', rows: layout.rows.slice(0, length) };
+}
+function cloneStoredFields(layout) {
+    if (layout.kind === 'none')
+        return layout;
+    if (layout.kind === 'single') {
+        return { kind: 'single', field: layout.field, values: layout.values.slice() };
+    }
+    return { kind: 'multi', rows: layout.rows.slice() };
+}
+/** Import from wire rows or lucaong snapshot. Empty storeFields + non-empty rows → multi (binary load without options). */
+function storedFieldsFromRows(rows, storeFields) {
+    if (storeFields.length === 0) {
+        const hasAny = rows.some(row => row != null && Object.keys(row).length > 0);
+        return hasAny ? { kind: 'multi', rows } : { kind: 'none' };
+    }
+    if (storeFields.length === 1) {
+        const field = storeFields[0];
+        const values = rows.map(row => row === null || row === void 0 ? void 0 : row[field]);
+        return { kind: 'single', field, values };
+    }
+    return { kind: 'multi', rows };
+}
+function storedFieldsJsonBytes(layout) {
+    if (layout.kind === 'none')
+        return 0;
+    if (layout.kind === 'multi') {
+        let total = 0;
+        for (const row of layout.rows) {
+            if (row != null)
+                total += JSON.stringify(row).length;
         }
+        return total;
     }
-    return localFreqs;
+    let total = 0;
+    const { field, values } = layout;
+    for (let i = 0; i < values.length; i++) {
+        const value = values[i];
+        if (value !== undefined)
+            total += JSON.stringify({ [field]: value }).length;
+    }
+    return total;
 }
-/** 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 storedFieldsSlotCount(layout) {
+    if (layout.kind === 'none')
+        return 0;
+    return layout.kind === 'single' ? layout.values.length : layout.rows.length;
+}
+function appendStoredFieldJsonEntry(table, heapChunks, heapOffRef, docIndex, jsonUtf8) {
+    table.writeUInt32LE(heapOffRef.value + 1, docIndex * 4);
+    const entry = Buffer.alloc(4 + jsonUtf8.length);
+    entry.writeUInt32LE(jsonUtf8.length, 0);
+    jsonUtf8.copy(entry, 4);
+    heapChunks.push(entry);
+    heapOffRef.value += entry.length;
+}
+/** MSv5 StoredFields section from {@link StoredFieldsLayout} (no intermediate row array). */
+function buildStoredFieldsWireSection(layout, nextId) {
+    if (layout.kind === 'multi') {
+        const rows = layout.rows.length >= nextId
+            ? layout.rows
+            : layout.rows.concat(new Array(nextId - layout.rows.length));
+        return buildStoredFieldsSection(rows, nextId);
+    }
+    const table = Buffer.alloc(nextId * 4);
+    if (layout.kind === 'none')
+        return table;
+    const heapChunks = [];
+    const heapOffRef = { value: 0 };
+    const { field, values } = layout;
+    for (let i = 0; i < nextId; i++) {
+        const value = values[i];
+        if (value === undefined)
+            continue;
+        const jsonUtf8 = Buffer.from(JSON.stringify({ [field]: value }), 'utf8');
+        appendStoredFieldJsonEntry(table, heapChunks, heapOffRef, i, jsonUtf8);
+    }
+    return heapChunks.length === 0 ? table : Buffer.concat([table, ...heapChunks]);
 }
-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;
+function storedFieldsTableEnd(storedOff, nextId, sectionEnd) {
+    const tableEnd = storedOff + nextId * 4;
+    if (tableEnd > sectionEnd) {
+        throw invalidFrozenIndex('stored fields table out of bounds');
+    }
+    return tableEnd;
+}
+function readStoredFieldJsonAt(buf, tableEnd, sectionEnd, rel) {
+    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');
+    }
+    return JSON.parse(buf.toString('utf8', jsonStart, jsonEnd));
+}
+/** MSv5 StoredFields section → layout (skips row materialization when storeFields hint allows). */
+function readStoredFieldsWireSection(buf, storedOff, nextId, sectionEnd, storeFields) {
+    const tableEnd = storedFieldsTableEnd(storedOff, nextId, sectionEnd);
+    if (storeFields.length === 1) {
+        const field = storeFields[0];
+        const values = new Array(nextId);
+        for (let i = 0; i < nextId; i++) {
+            const rel = buf.readUInt32LE(storedOff + i * 4);
+            if (rel === 0)
+                continue;
+            const row = readStoredFieldJsonAt(buf, tableEnd, sectionEnd, rel);
+            values[i] = row[field];
+        }
+        return { kind: 'single', field, values };
+    }
+    if (storeFields.length === 0) {
+        let hasAny = false;
+        for (let i = 0; i < nextId; i++) {
+            if (buf.readUInt32LE(storedOff + i * 4) !== 0) {
+                hasAny = true;
+                break;
+            }
+        }
+        if (!hasAny)
+            return { kind: 'none' };
     }
-    return documentFields;
+    const rows = readStoredFieldsSection(buf, storedOff, nextId, sectionEnd);
+    return storedFieldsFromRows(rows, storeFields);
 }
 
 const SUPPORTED_SERIALIZATION_VERSIONS = new Set([1, 2]);
@@ -2345,7 +2701,7 @@ function buildFrozenAssembleParamsFromMiniSearchSnapshot(snapshot, options) {
     let shortIdRemap = null;
     const resolvedNextId = useDense ? documentCount : nextId;
     const externalIds = new Array(resolvedNextId);
-    const storedFields = new Array(externalIds.length);
+    const storedFieldRows = new Array(externalIds.length);
     if (useDense) {
         shortIdRemap = new Uint32Array(nextId);
         shortIdRemap.fill(DISCARDED_DOC_ID);
@@ -2357,7 +2713,7 @@ function buildFrozenAssembleParamsFromMiniSearchSnapshot(snapshot, options) {
             const shortIdStr = String(shortId);
             shortIdRemap[shortId] = dense;
             externalIds[dense] = snapshot.documentIds[shortIdStr];
-            storedFields[dense] = snapshot.storedFields[shortIdStr];
+            storedFieldRows[dense] = snapshot.storedFields[shortIdStr];
             dense++;
         }
     }
@@ -2365,7 +2721,7 @@ function buildFrozenAssembleParamsFromMiniSearchSnapshot(snapshot, options) {
         for (const [shortIdStr, id] of Object.entries(snapshot.documentIds)) {
             const shortId = parseInt(shortIdStr, 10);
             externalIds[shortId] = id;
-            storedFields[shortId] = snapshot.storedFields[shortIdStr];
+            storedFieldRows[shortId] = snapshot.storedFields[shortIdStr];
         }
     }
     const idLookup = createIdToShortIdLookup(externalIds, resolvedNextId);
@@ -2388,6 +2744,7 @@ function buildFrozenAssembleParamsFromMiniSearchSnapshot(snapshot, options) {
     }
     const searchableMap = buildSearchableMapFromSnapshot(snapshot);
     const flat = buildFlatPostingsFromSearchableMap(searchableMap, fieldCount, resolvedNextId, shortIdRemap);
+    const storedFields = storedFieldsFromRows(storedFieldRows, opts.storeFields);
     return {
         options: opts,
         documentCount,
@@ -2689,321 +3046,121 @@ function collectZstdPayloadSections(directory, uncompressedLength, payloadCrc32)
                 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');
+    }
+    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');
         }
-        storedFields[i] = JSON.parse(buf.toString('utf8', jsonStart, jsonEnd));
     }
-    return storedFields;
+    return { sections, consume, finish };
 }
-/** 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);
+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;
     }
-    else {
-        validateTreeShape(snap.treeShape, termCount);
+    if (prevEnd !== uncompressedLength) {
+        throw new Error('MSv5 uncompressed payload length mismatch');
     }
 }
-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);
+/** 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');
     }
-    return Buffer.concat(chunks);
-}
-function buildExternalIdsSection(externalIds, nextId) {
-    const chunks = [];
-    for (let i = 0; i < nextId; i++) {
-        writeExternalId(chunks, externalIds[i]);
+    if (payloadCodec === CODEC_RAW && compressedLength !== uncompressedLength) {
+        throw new Error('MSv5 raw payload length mismatch');
     }
-    return Buffer.concat(chunks);
+    return {
+        payloadCodec,
+        slice: fileBuf.subarray(payloadOffset, payloadOffset + compressedLength),
+        uncompressedLength,
+        payloadCrc32,
+    };
 }
-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;
+/** 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);
     }
-    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}`);
-            }
+    if (payloadCodec === CODEC_ZSTD) {
+        if (!zstdAvailable()) {
+            throw zstdUnavailableReadError();
         }
-        else {
-            validateTermTreeLeaves(val, termCount);
+        // 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}`);
 }
-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));
+/** 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);
     }
-    return tree;
+    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);
 }
 
 /** Global wire flags for {@link FreqArray} width. */
@@ -3297,11 +3454,14 @@ function encodeFrozenSnapshotMsv5(snap, termTree, packedTermIndex) {
     const flFlags = fieldLengthMatrixWireFlags(snap.fieldLengthMatrix);
     const freqFlags = freqWireFlags(snap.postings.allFreqs);
     const globalFlags = postingsWire.flags | flFlags | freqFlags;
+    const storedFieldsSection = snap.storedFieldsLayout != null
+        ? buildStoredFieldsWireSection(snap.storedFieldsLayout, snap.nextId)
+        : buildStoredFieldsSection(snap.storedFields, snap.nextId);
     const rawSections = [
         buildCoreSectionWithTermCount(snap),
         buildFieldNamesSection(fieldNames),
         buildExternalIdsSection(snap.externalIds, snap.nextId),
-        buildStoredFieldsSection(snap.storedFields, snap.nextId),
+        storedFieldsSection,
         buildTermTreeSectionColumnar(packed),
         bufferFromView(snap.avgFieldLength),
         buildFieldLengthMatrixSection(snap.fieldLengthMatrix),
@@ -3325,11 +3485,14 @@ async function encodeFrozenSnapshotMsv5Async(snap, termTree, packedTermIndex) {
     const flFlags = fieldLengthMatrixWireFlags(snap.fieldLengthMatrix);
     const freqFlags = freqWireFlags(snap.postings.allFreqs);
     const globalFlags = postingsWire.flags | flFlags | freqFlags;
+    const storedFieldsSection = snap.storedFieldsLayout != null
+        ? buildStoredFieldsWireSection(snap.storedFieldsLayout, snap.nextId)
+        : buildStoredFieldsSection(snap.storedFields, snap.nextId);
     const rawSections = [
         buildCoreSectionWithTermCount(snap),
         buildFieldNamesSection(fieldNames),
         buildExternalIdsSection(snap.externalIds, snap.nextId),
-        buildStoredFieldsSection(snap.storedFields, snap.nextId),
+        storedFieldsSection,
         buildTermTreeSectionColumnar(packed),
         bufferFromView(snap.avgFieldLength),
         buildFieldLengthMatrixSection(snap.fieldLengthMatrix),
@@ -3359,7 +3522,7 @@ function validateMsv5Container(buf) {
     }
     return { globalFlags, directory };
 }
-function decodeMsv5Sections(globalFlags, sections) {
+function decodeMsv5Sections(globalFlags, sections, hints) {
     const core = sections[0 /* Msv5SectionId.Core */];
     if (core.length !== 16) {
         throw invalidFrozenIndex('core section size mismatch');
@@ -3374,7 +3537,12 @@ function decodeMsv5Sections(globalFlags, sections) {
         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 storedFieldsLayout = hints != null
+        ? readStoredFieldsWireSection(sections[3 /* Msv5SectionId.StoredFields */], 0, nextId, sections[3 /* Msv5SectionId.StoredFields */].length, hints.storeFields)
+        : undefined;
+    const storedFields = storedFieldsLayout != null
+        ? new Array(nextId)
+        : 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);
@@ -3392,6 +3560,7 @@ function decodeMsv5Sections(globalFlags, sections) {
         avgFieldLength,
         externalIds,
         storedFields,
+        storedFieldsLayout,
         fieldLengthMatrix,
         treeShape: [],
         packedTermIndex,
@@ -3400,13 +3569,13 @@ function decodeMsv5Sections(globalFlags, sections) {
     validateFrozenSnapshot(snap);
     return snap;
 }
-function decodeFrozenSnapshotMsv5(buf) {
+function decodeFrozenSnapshotMsv5(buf, hints) {
     const { globalFlags, directory } = validateMsv5Container(buf);
-    return decodeMsv5Sections(globalFlags, loadMsv5Sections(buf, directory));
+    return decodeMsv5Sections(globalFlags, loadMsv5Sections(buf, directory), hints);
 }
-async function decodeFrozenSnapshotMsv5Async(buf) {
+async function decodeFrozenSnapshotMsv5Async(buf, hints) {
     const { globalFlags, directory } = validateMsv5Container(buf);
-    return decodeMsv5Sections(globalFlags, await loadMsv5SectionsAsync(buf, directory));
+    return decodeMsv5Sections(globalFlags, await loadMsv5SectionsAsync(buf, directory), hints);
 }
 
 /** Encode a frozen snapshot as a binary buffer. */
@@ -3420,12 +3589,12 @@ function encodeFrozenSnapshotAsync(snap, termTree, packedTermIndex) {
 
 const LEGACY_MAGICS = new Set(['MSv1', 'MSv2', 'MSv3', 'MSv4']);
 /** Decode a frozen binary snapshot buffer. */
-function decodeFrozenSnapshot(buf) {
+function decodeFrozenSnapshot(buf, hints) {
     assertBufferLength(buf, 8);
     const magic = buf.toString('ascii', 0, 4);
     const version = buf.readUInt16LE(4);
     if (isMsv5Buffer(buf) && version === 5) {
-        return decodeFrozenSnapshotMsv5(buf);
+        return decodeFrozenSnapshotMsv5(buf, hints);
     }
     if (LEGACY_MAGICS.has(magic)) {
         throw invalidFrozenIndex('Unsupported frozen binary snapshot; re-build with saveBinarySync() or from lucaong JSON');
@@ -3433,82 +3602,283 @@ function decodeFrozenSnapshot(buf) {
     throw invalidFrozenIndex('Unsupported frozen binary snapshot');
 }
 /** Async frozen snapshot decode (streaming zstd). */
-async function decodeFrozenSnapshotAsync(buf) {
+async function decodeFrozenSnapshotAsync(buf, hints) {
     assertBufferLength(buf, 8);
     const version = buf.readUInt16LE(4);
     if (isMsv5Buffer(buf) && version === 5) {
-        return decodeFrozenSnapshotMsv5Async(buf);
+        return decodeFrozenSnapshotMsv5Async(buf, hints);
+    }
+    return decodeFrozenSnapshot(buf, hints);
+}
+
+const DEFAULT_CAPACITY = 16;
+/** Growable unsigned 32-bit column (build scratch; narrowed to u16 at finalize when possible). */
+class GrowableUint32Column {
+    constructor(initialCapacity = DEFAULT_CAPACITY) {
+        this._len = 0;
+        this._buf = new Uint32Array(Math.max(1, initialCapacity));
+    }
+    get length() {
+        return this._len;
+    }
+    push(value) {
+        if (this._len >= this._buf.length) {
+            const grown = new Uint32Array(Math.max(1, this._buf.length * 2));
+            grown.set(this._buf);
+            this._buf = grown;
+        }
+        this._buf[this._len++] = value;
+    }
+    copyRangeInto(sourceOffset, length, target, targetOffset, docIdWidth) {
+        if (docIdWidth === 16) {
+            const out = target;
+            for (let i = 0; i < length; i++)
+                out[targetOffset + i] = this._buf[sourceOffset + i];
+        }
+        else {
+            const out = target;
+            for (let i = 0; i < length; i++)
+                out[targetOffset + i] = this._buf[sourceOffset + i];
+        }
+    }
+    truncate(length) {
+        this._len = length;
+        if (length > 0 && length < this._buf.length) {
+            this._buf = this._buf.slice(0, length);
+        }
+    }
+}
+/** Growable frequency column (u16 cells; matches frozen clamp range). */
+class GrowableFreqColumn {
+    constructor(initialCapacity = DEFAULT_CAPACITY) {
+        this._len = 0;
+        this._buf = new Uint16Array(Math.max(1, initialCapacity));
+    }
+    get length() {
+        return this._len;
+    }
+    push(freq) {
+        if (this._len >= this._buf.length) {
+            const grown = new Uint16Array(Math.max(1, this._buf.length * 2));
+            grown.set(this._buf);
+            this._buf = grown;
+        }
+        this._buf[this._len++] = clampFreq(freq);
+    }
+    copyRangeInto(sourceOffset, length, target, targetOffset) {
+        for (let i = 0; i < length; i++) {
+            target[targetOffset + i] = this._buf[sourceOffset + i];
+        }
+    }
+    truncate(length) {
+        this._len = length;
+        if (length > 0 && length < this._buf.length) {
+            this._buf = this._buf.slice(0, length);
+        }
+    }
+}
+/**
+ * Single-pass postings accumulator for {@link FrozenIndexBuilder}.
+ * One global TypedArray stream per docIds/freqs; per-slot range metadata only.
+ */
+class IncrementalPostingsAccumulator {
+    constructor(fieldCount, hints) {
+        var _a;
+        this._slots = new Map();
+        this._totalPostings = 0;
+        this._maxFreq = 0;
+        this._fieldCount = fieldCount;
+        const cap = Math.max(DEFAULT_CAPACITY, (_a = hints === null || hints === void 0 ? void 0 : hints.estimatedTotalPostings) !== null && _a !== void 0 ? _a : 0);
+        this._docIds = new GrowableUint32Column(cap);
+        this._freqs = new GrowableFreqColumn(cap);
+    }
+    get totalPostings() {
+        return this._totalPostings;
+    }
+    get maxFreq() {
+        return this._maxFreq;
+    }
+    append(termIndex, fieldId, docId, freq) {
+        const slot = termIndex * this._fieldCount + fieldId;
+        const writeIdx = this._docIds.length;
+        this._docIds.push(docId);
+        const v = clampFreq(freq);
+        this._freqs.push(v);
+        if (v > this._maxFreq)
+            this._maxFreq = v;
+        this._totalPostings++;
+        let ranges = this._slots.get(slot);
+        if (ranges == null) {
+            ranges = { starts: [writeIdx], lengths: [1] };
+            this._slots.set(slot, ranges);
+            return;
+        }
+        const last = ranges.starts.length - 1;
+        const end = ranges.starts[last] + ranges.lengths[last];
+        if (end === writeIdx) {
+            ranges.lengths[last]++;
+        }
+        else {
+            ranges.starts.push(writeIdx);
+            ranges.lengths.push(1);
+        }
+    }
+    clear() {
+        this._slots.clear();
+        // Drop global scratch backing so finalize does not retain duplicate posting bytes.
+        this._docIds.truncate(0);
+        this._freqs.truncate(0);
+    }
+    copySlot(ranges, allDocIds, allFreqs, write, docIdWidth) {
+        for (let r = 0; r < ranges.starts.length; r++) {
+            const start = ranges.starts[r];
+            const len = ranges.lengths[r];
+            this._docIds.copyRangeInto(start, len, allDocIds, write, docIdWidth);
+            this._freqs.copyRangeInto(start, len, allFreqs, write);
+            write += len;
+        }
+        return write;
+    }
+    slotLength(ranges) {
+        let n = 0;
+        for (let i = 0; i < ranges.lengths.length; i++)
+            n += ranges.lengths[i];
+        return n;
+    }
+    finalize(termCount, nextId) {
+        const fieldCount = this._fieldCount;
+        const totalPostings = this._totalPostings;
+        const maxFreq = this._maxFreq;
+        const slots = this._slots;
+        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 ranges = slots.get(slot);
+                    const len = ranges == null ? 0 : this.slotLength(ranges);
+                    denseOffsets[slot] = write;
+                    denseLengths[slot] = len;
+                    if (len > 0) {
+                        write = this.copySlot(ranges, allDocIds, allFreqs, write, docIdWidth);
+                        slots.delete(slot);
+                    }
+                }
+            }
+            slots.clear();
+            this.clear();
+            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 ranges = slots.get(slot);
+                const len = ranges == null ? 0 : this.slotLength(ranges);
+                if (len === 0)
+                    continue;
+                sparseFieldIdsScratch.push(f);
+                sparseOffsets.push(write);
+                sparseLengths.push(len);
+                write = this.copySlot(ranges, allDocIds, allFreqs, write, docIdWidth);
+                slots.delete(slot);
+            }
+            termStarts[ti + 1] = sparseFieldIdsScratch.length;
+        }
+        slots.clear();
+        this.clear();
+        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),
+        };
     }
-    return decodeFrozenSnapshot(buf);
 }
 
-function getOrCreateTermIndex(state, index, term) {
+function getOrCreateTermIndex(termCount, index, term) {
     const existing = index.get(term);
     if (existing != null)
         return existing;
-    const ti = state.terms.length;
-    state.terms.push(term);
+    const ti = termCount.value;
+    termCount.value++;
     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) {
+        var _a, _b;
+        this._termCount = { value: 0 };
+        this._fieldTermFreqScratch = new Map();
+        this._tokenScratch = [];
         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 = [];
+        const estimatedDocs = (_a = hints === null || hints === void 0 ? void 0 : hints.estimatedDocumentCount) !== null && _a !== void 0 ? _a : 0;
+        const perSlot = (_b = hints === null || hints === void 0 ? void 0 : hints.estimatedPostingsPerSlot) !== null && _b !== void 0 ? _b : 4;
+        this._postings = new IncrementalPostingsAccumulator(this._fieldCount, {
+            estimatedTotalPostings: estimatedDocs > 0 ? estimatedDocs * perSlot : undefined,
+        });
         this._avgFieldLength = [];
         this._seenIds = new Set();
         this._nextId = 0;
         this._frozen = false;
         const estimated = hints === null || hints === void 0 ? void 0 : hints.estimatedDocumentCount;
+        this._storedFields = createStoredFieldsLayout(this._options.storeFields, estimated !== null && estimated !== void 0 ? estimated : 0);
         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() {
@@ -3529,22 +3899,23 @@ class FrozenIndexBuilder {
         this._seenIds.add(id);
         const shortId = this._nextId++;
         this._externalIds[shortId] = id;
-        this._storedFields[shortId] = saveStoredFieldsForDocument(storeFields, extractField, document);
+        writeStoredField(this._storedFields, shortId, 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 fieldText = typeof fieldValue === 'string'
+                ? fieldValue
+                : stringifyField(fieldValue, field);
             const fieldId = this._fieldIds[field];
-            const uniqueTerms = new Set(tokens).size;
-            const localFreqs = collectFieldTermFreqs(tokens, field, processTerm);
+            const uniqueTerms = collectFieldTermFreqsFromFieldInto(this._fieldTermFreqScratch, this._tokenScratch, tokenize, fieldText, 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);
-            }
+            this._fieldTermFreqScratch.forEach((freq, term) => {
+                const ti = getOrCreateTermIndex(this._termCount, this._index, term);
+                this._postings.append(ti, fieldId, shortId, freq);
+            });
         }
     }
     /**
@@ -3601,7 +3972,11 @@ class FrozenIndexBuilder {
         }
         this._frozen = true;
         const documentCount = this._nextId;
-        const postings = finalizeFlatPostings(this._postingsState, documentCount);
+        const termCount = this._termCount.value;
+        const postings = this._postings.finalize(termCount, documentCount);
+        const radixTree = this._index.radixTree;
+        this._index = null;
+        const index = fromRadixTree(radixTree, termCount);
         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;
@@ -3610,12 +3985,8 @@ class FrozenIndexBuilder {
         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 storedFields = resizeStoredFields(this._storedFields, documentCount);
         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,
@@ -3627,8 +3998,8 @@ class FrozenIndexBuilder {
             storedFields,
             fieldLengthMatrix: materializeFieldLengthMatrix(this._fieldLengthData, documentCount * this._fieldCount),
             avgFieldLength,
-            index: fromRadixTree(this._index.radixTree, this._terms.length),
-            termCount: this._terms.length,
+            index,
+            termCount,
             postings,
         };
     }
@@ -4042,7 +4413,7 @@ function shallowCopyJsSnapshotFields(params) {
     return {
         fieldIds: { ...params.fieldIds },
         options: shallowCopyOptions(params.options),
-        storedFields: params.storedFields.slice(),
+        storedFields: cloneStoredFields(params.storedFields),
     };
 }
 /**
@@ -4127,7 +4498,7 @@ class FrozenMiniSearch {
             fieldIds: this._fieldIds,
             getFieldLength: (docId, fieldId) => this.getFieldLength(docId, fieldId),
             getExternalId: docId => this._externalIds[docId],
-            getStoredFields: docId => this._storedFields[docId],
+            getStoredFields: docId => readStoredFields(this._storedFields, docId),
         };
         this._queryEngineParams = {
             fields: this._options.fields,
@@ -4139,7 +4510,7 @@ class FrozenMiniSearch {
                     const id = this._externalIds[shortId];
                     if (id === undefined)
                         continue;
-                    callback(shortId, id, this._storedFields[shortId]);
+                    callback(shortId, id, readStoredFields(this._storedFields, shortId));
                 }
             }),
             aggregateContext: this._aggregateContext,
@@ -4150,11 +4521,7 @@ class FrozenMiniSearch {
     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 storedJson = storedFieldsJsonBytes(this._storedFields);
         const radixEst = this._index.packedByteLength();
         const idMapBytes = this._idLookup.mode === 'lazy-map' ? this._idLookup.mapEntryCount * 32 : 0;
         const estimatedStructuredBytes = postingsStats.totalTypedBytes
@@ -4184,7 +4551,7 @@ class FrozenMiniSearch {
             },
             documents: {
                 externalIdsSlots: this._externalIds.length,
-                storedFieldsSlots: this._storedFields.length,
+                storedFieldsSlots: storedFieldsSlotCount(this._storedFields),
                 idLookupMode: this._idLookup.mode,
                 idToShortIdEntries: this._idLookup.mapEntryCount,
                 fieldLengthMatrixBytes: this._fieldLengthMatrix.byteLength,
@@ -4199,10 +4566,10 @@ class FrozenMiniSearch {
     }
     getStoredFields(id) {
         const shortId = this._idLookup.get(id);
-        return shortId == null ? undefined : this._storedFields[shortId];
+        return shortId == null ? undefined : readStoredFields(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]);
+        return finalizeRawSearchResults(this.executeQuery(query, searchOptions), query, searchOptions, this._options.searchOptions, docId => this._externalIds[docId], docId => readStoredFields(this._storedFields, docId));
     }
     autoSuggest(queryString, options = {}) {
         const merged = { ...this._options.autoSuggestOptions, ...options };
@@ -4218,7 +4585,8 @@ class FrozenMiniSearch {
             fieldNames: fieldNamesFromFieldIds(this._fieldIds),
             avgFieldLength: this._avgFieldLength,
             externalIds: this._externalIds,
-            storedFields: this._storedFields,
+            storedFields: new Array(this._nextId),
+            storedFieldsLayout: this._storedFields,
             fieldLengthMatrix: fieldLengthMatrixForWire(this._fieldLengthMatrix),
             treeShape: [],
             postings: this._postings,
@@ -4234,7 +4602,8 @@ class FrozenMiniSearch {
             fieldNames: fieldNamesFromFieldIds(this._fieldIds),
             avgFieldLength: this._avgFieldLength,
             externalIds: this._externalIds,
-            storedFields: this._storedFields,
+            storedFields: new Array(this._nextId),
+            storedFieldsLayout: this._storedFields,
             fieldLengthMatrix: fieldLengthMatrixForWire(this._fieldLengthMatrix),
             treeShape: [],
             postings: this._postings,
@@ -4242,16 +4611,20 @@ class FrozenMiniSearch {
     }
     /** Load a frozen binary snapshot. */
     static loadBinarySync(buffer, options = {}) {
-        const snap = decodeFrozenSnapshot(buffer);
+        var _a;
+        const storeFields = (_a = options.storeFields) !== null && _a !== void 0 ? _a : defaultFrozenLoadOptions.storeFields;
+        const snap = decodeFrozenSnapshot(buffer, { storeFields });
         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);
+        var _a;
+        const storeFields = (_a = options.storeFields) !== null && _a !== void 0 ? _a : defaultFrozenLoadOptions.storeFields;
+        const snap = await decodeFrozenSnapshotAsync(buffer, { storeFields });
         return FrozenMiniSearch.fromBinarySnapshot(snap, options);
     }
     static fromBinarySnapshot(snap, options) {
-        var _a, _b;
+        var _a, _b, _c;
         const snapshotFields = (_a = snap.fieldNames) !== null && _a !== void 0 ? _a : fieldNamesFromFieldIds(snap.fieldIds);
         if (options.fields != null) {
             assertFieldsMatchSnapshot(options.fields, snap.fieldIds);
@@ -4279,7 +4652,7 @@ class FrozenMiniSearch {
             fieldCount: snap.fieldCount,
             externalIds: snap.externalIds,
             idLookup,
-            storedFields: snap.storedFields,
+            storedFields: (_c = snap.storedFieldsLayout) !== null && _c !== void 0 ? _c : storedFieldsFromRows(snap.storedFields, opts.storeFields),
             fieldLengthMatrix: snap.fieldLengthMatrix,
             avgFieldLength: snap.avgFieldLength,
             index,
@@ -4334,4 +4707,4 @@ class FrozenMiniSearch {
 }
 FrozenMiniSearch.wildcard = WILDCARD_QUERY;
 
-export { AND, AND_NOT, FrozenIndexBuilder, OR, assembleFrozen, buildFrozenFromDocuments, createFrozenIndexBuilder, FrozenMiniSearch as default, freezeFrozenIndexBuilder, frozenMemoryBreakdown };
+export { AND, AND_NOT, FrozenIndexBuilder, FrozenMiniSearch, OR, assembleFrozen, buildFrozenFromDocuments, createFrozenIndexBuilder, FrozenMiniSearch as default, freezeFrozenIndexBuilder, frozenMemoryBreakdown };