@yoch/frozenminisearch 1.1.0 → 1.2.1

package/dist/es/index.js

@@ -256,7 +256,9 @@ function finalizeSearchResults(params) {
             queryTerms: terms,
             match,
         };
-        Object.assign(result, getStoredFields(docId));
+        if (getStoredFields != null) {
+            Object.assign(result, getStoredFields(docId));
+        }
         if (filter == null || filter(result)) {
             results.push(result);
         }
@@ -1640,9 +1642,11 @@ const FLAG_FL_U8 = 8;
 const FLAG_FL_U16 = 16;
 const FLAG_FREQ_U16 = 32;
 const CODEC_RAW = 0;
+/** Deflate/inflate (`node:zlib`) on the whole payload. */
+const CODEC_ZLIB = 1;
 /** Zstandard (`node:zlib`) on the whole payload. */
 const CODEC_ZSTD = 3;
-/** Single concatenated payload, one zstd stream (or raw). */
+/** Single concatenated payload, one compressed stream (or raw). */
 const MSV5_FORMAT_REV_PAYLOAD = 1;
 /** Do not compress payloads smaller than this (bytes). */
 const MSV5_MIN_COMPRESS_BYTES = 64;
@@ -2762,33 +2766,43 @@ function buildFrozenAssembleParamsFromMiniSearchSnapshot(snapshot, options) {
     };
 }
 
-/** Hard cap on the uncompressed payload, rejected before allocation (zstd-bomb guard).
+/** Hard cap on the uncompressed payload, rejected before allocation (compressed-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;
+const MSV5_COMPRESSED_PAYLOAD_EXCEEDS_LENGTH = 'MSv5 compressed payload exceeds declared length';
+const MSV5_DECOMPRESSED_PAYLOAD_LENGTH_MISMATCH = 'MSv5 decompressed payload length mismatch';
 // 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.
+// module load) so it stays mockable in tests. On older runtimes we degrade gracefully: `auto`
+// tries zlib once (or raw if it does not help). When zstd is available, `auto` tries zstd once
+// and stays raw if it does not shrink — no second pass. Reads of a zstd payload throw a clear,
+// actionable error on runtimes without zstd.
 function zstdAvailable() {
     return typeof zlib.zstdCompressSync === 'function';
 }
+function zstdUnavailableWriteError() {
+    return new Error('MSv5 snapshot requested zstd compression, but this Node.js runtime lacks node:zlib zstd '
+        + 'support (added in Node 22.15.0). Upgrade Node.js, or use compression: "auto", "raw", '
+        + 'or "zlib".');
+}
 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.');
+        + 'newer runtime with compression: "raw" or "zlib".');
 }
 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' });
+    process.emitWarning('node:zlib zstd APIs are unavailable (Node.js < 22.15.0); compression: "auto" falls back to '
+        + 'zlib when it shrinks the payload, otherwise raw (uncompressed). Upgrade to Node 22.15.0+ '
+        + 'for zstd.', { code: 'MINISEARCH_MSV5_ZSTD_UNAVAILABLE' });
 }
 function assertPayloadFormatRev(buf) {
     const rev = buf.readUInt16LE(MSV5_FORMAT_REV_OFFSET);
@@ -2838,23 +2852,26 @@ function msv5ZstdCompressOptions(uncompressed) {
         },
     };
 }
-/** 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 };
-    }
+function rawPayloadChoice(uncompressed) {
     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 };
+/** Auto mode: one compression attempt; keep it only when strictly smaller than raw. */
+function pickAutoPayloadCodec(uncompressed, compressed, codec) {
+    if (compressed.length < uncompressed.length) {
+        return {
+            payload: compressed,
+            codec,
+            zstdLevel: codec === CODEC_ZSTD ? MSV5_ZSTD_LEVEL : 0,
+        };
     }
+    return rawPayloadChoice(uncompressed);
+}
+function zstdPayloadChoiceSync(uncompressed) {
     if (!zstdAvailable()) {
-        warnZstdSaveFallbackOnce();
-        return { payload: uncompressed, codec: CODEC_RAW, zstdLevel: 0 };
+        throw zstdUnavailableWriteError();
     }
     const compressed = zlib.zstdCompressSync(uncompressed, msv5ZstdCompressOptions(uncompressed));
-    return pickPayloadCodec(uncompressed, compressed);
+    return { payload: compressed, codec: CODEC_ZSTD, zstdLevel: MSV5_ZSTD_LEVEL };
 }
 /**
  * Async zstd via {@link zstdCompress} (not {@link zstdCompressSync}).
@@ -2873,16 +2890,91 @@ function zstdCompressAsync(uncompressed) {
         });
     });
 }
-async function choosePayloadCodecAsync(uncompressed) {
+async function zstdPayloadChoiceAsync(uncompressed) {
+    if (!zstdAvailable()) {
+        throw zstdUnavailableWriteError();
+    }
+    const compressed = await zstdCompressAsync(uncompressed);
+    return { payload: compressed, codec: CODEC_ZSTD, zstdLevel: MSV5_ZSTD_LEVEL };
+}
+function zlibPayloadChoiceSync(uncompressed) {
+    const compressed = zlib.deflateSync(uncompressed);
+    return { payload: compressed, codec: CODEC_ZLIB, zstdLevel: 0 };
+}
+function zlibCompressAsync(uncompressed) {
+    return new Promise((resolve, reject) => {
+        zlib.deflate(uncompressed, (err, compressed) => {
+            if (err != null) {
+                reject(err);
+                return;
+            }
+            resolve(compressed);
+        });
+    });
+}
+async function zlibPayloadChoiceAsync(uncompressed) {
+    const compressed = await zlibCompressAsync(uncompressed);
+    return { payload: compressed, codec: CODEC_ZLIB, zstdLevel: 0 };
+}
+const autoSyncCompressors = {
+    zstd: (uncompressed) => zlib.zstdCompressSync(uncompressed, msv5ZstdCompressOptions(uncompressed)),
+    zlib: (uncompressed) => zlib.deflateSync(uncompressed),
+};
+const autoAsyncCompressors = {
+    zstd: zstdCompressAsync,
+    zlib: zlibCompressAsync,
+};
+function autoPayloadChoice(uncompressed, compressors) {
     if (uncompressed.length < MSV5_MIN_COMPRESS_BYTES) {
-        return { payload: uncompressed, codec: CODEC_RAW, zstdLevel: 0 };
+        return rawPayloadChoice(uncompressed);
     }
     if (!zstdAvailable()) {
         warnZstdSaveFallbackOnce();
-        return { payload: uncompressed, codec: CODEC_RAW, zstdLevel: 0 };
+        return pickAutoPayloadCodec(uncompressed, compressors.zlib(uncompressed), CODEC_ZLIB);
+    }
+    return pickAutoPayloadCodec(uncompressed, compressors.zstd(uncompressed), CODEC_ZSTD);
+}
+async function autoPayloadChoiceAsync(uncompressed, compressors) {
+    if (uncompressed.length < MSV5_MIN_COMPRESS_BYTES) {
+        return rawPayloadChoice(uncompressed);
+    }
+    if (!zstdAvailable()) {
+        warnZstdSaveFallbackOnce();
+        return pickAutoPayloadCodec(uncompressed, await compressors.zlib(uncompressed), CODEC_ZLIB);
+    }
+    return pickAutoPayloadCodec(uncompressed, await compressors.zstd(uncompressed), CODEC_ZSTD);
+}
+function choosePayloadCodecSync(uncompressed, compression = 'auto') {
+    switch (compression) {
+        case 'raw':
+            return rawPayloadChoice(uncompressed);
+        case 'zstd':
+            return zstdPayloadChoiceSync(uncompressed);
+        case 'zlib':
+            return zlibPayloadChoiceSync(uncompressed);
+        case 'auto':
+            return autoPayloadChoice(uncompressed, autoSyncCompressors);
+        default: {
+            const _exhaustive = compression;
+            return _exhaustive;
+        }
+    }
+}
+async function choosePayloadCodecAsync(uncompressed, compression = 'auto') {
+    switch (compression) {
+        case 'raw':
+            return rawPayloadChoice(uncompressed);
+        case 'zstd':
+            return await zstdPayloadChoiceAsync(uncompressed);
+        case 'zlib':
+            return await zlibPayloadChoiceAsync(uncompressed);
+        case 'auto':
+            return await autoPayloadChoiceAsync(uncompressed, autoAsyncCompressors);
+        default: {
+            const _exhaustive = compression;
+            return _exhaustive;
+        }
     }
-    const compressed = await zstdCompressAsync(uncompressed);
-    return pickPayloadCodec(uncompressed, compressed);
 }
 function concatAndValidateSections(rawSections) {
     if (rawSections.length !== MSV5_SECTION_COUNT) {
@@ -2937,16 +3029,16 @@ function buildMsv5AssembledFile(globalFlags, entries, uncompressedLength, payloa
 }
 /**
  * MSv5 on disk: header + catalogue (uncompressed offsets) + **one** payload blob
- * (raw concatenation or a single zstd stream over it).
+ * (raw concatenation or a single compressed stream over it).
  */
-function assembleMsv5File(globalFlags, rawSections) {
+function assembleMsv5File(globalFlags, rawSections, compression = 'auto') {
     const { uncompressed, entries, payloadCrc32 } = concatAndValidateSections(rawSections);
-    const { payload, codec, zstdLevel } = choosePayloadCodecSync(uncompressed);
+    const { payload, codec, zstdLevel } = choosePayloadCodecSync(uncompressed, compression);
     return buildMsv5AssembledFile(globalFlags, entries, uncompressed.length, payloadCrc32, payload, codec, zstdLevel);
 }
-async function assembleMsv5FileAsync(globalFlags, rawSections) {
+async function assembleMsv5FileAsync(globalFlags, rawSections, compression = 'auto') {
     const { uncompressed, entries, payloadCrc32 } = concatAndValidateSections(rawSections);
-    const { payload, codec, zstdLevel } = await choosePayloadCodecAsync(uncompressed);
+    const { payload, codec, zstdLevel } = await choosePayloadCodecAsync(uncompressed, compression);
     return buildMsv5AssembledFile(globalFlags, entries, uncompressed.length, payloadCrc32, payload, codec, zstdLevel);
 }
 function readMsv5SectionDirectory(buf) {
@@ -2990,11 +3082,11 @@ function sectionsFromPayload(payload, directory, payloadCrc32) {
         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) {
+/** Streaming compressed reader: keeps only one section in memory at a time.
+ *  No `maxOutputLength` on Transform streams: output is bounded by accumulating `streamOffset`
+ *  against the header's `uncompressedLength` (same 1 GiB cap checked upfront). Sync load uses
+ *  `maxOutputLength` because it materializes the whole payload at once. */
+function collectCompressedPayloadSections(directory, uncompressedLength, payloadCrc32) {
     if (uncompressedLength > MSV5_MAX_UNCOMPRESSED_BYTES) {
         throw new Error('MSv5 payload exceeds 1 GiB limit');
     }
@@ -3014,7 +3106,7 @@ function collectZstdPayloadSections(directory, uncompressedLength, payloadCrc32)
     }
     function consume(chunk) {
         if (streamOffset + chunk.length > uncompressedLength) {
-            throw new Error('MSv5 zstd payload exceeds declared length');
+            throw new Error(MSV5_COMPRESSED_PAYLOAD_EXCEEDS_LENGTH);
         }
         payloadCrc = crc32Update(payloadCrc, chunk);
         let off = 0;
@@ -3050,7 +3142,7 @@ function collectZstdPayloadSections(directory, uncompressedLength, payloadCrc32)
     function finish() {
         emitEmptySections();
         if (streamOffset !== uncompressedLength || sectionId !== directory.length) {
-            throw new Error('MSv5 zstd decompressed length mismatch');
+            throw new Error(MSV5_DECOMPRESSED_PAYLOAD_LENGTH_MISMATCH);
         }
         if (payloadCrc !== payloadCrc32) {
             throw new Error('MSv5 payload CRC mismatch');
@@ -3059,9 +3151,15 @@ function collectZstdPayloadSections(directory, uncompressedLength, payloadCrc32)
     return { sections, consume, finish };
 }
 function loadMsv5SectionsFromZstdStream(compressed, directory, uncompressedLength, payloadCrc32) {
+    return loadMsv5SectionsFromCompressedStream(compressed, directory, uncompressedLength, payloadCrc32, () => zlib.createZstdDecompress());
+}
+function loadMsv5SectionsFromZlibStream(compressed, directory, uncompressedLength, payloadCrc32) {
+    return loadMsv5SectionsFromCompressedStream(compressed, directory, uncompressedLength, payloadCrc32, () => zlib.createInflate());
+}
+function loadMsv5SectionsFromCompressedStream(compressed, directory, uncompressedLength, payloadCrc32, createStream) {
     return new Promise((resolve, reject) => {
-        const collector = collectZstdPayloadSections(directory, uncompressedLength, payloadCrc32);
-        const stream = zlib.createZstdDecompress();
+        const collector = collectCompressedPayloadSections(directory, uncompressedLength, payloadCrc32);
+        const stream = createStream();
         stream.on('data', (chunk) => {
             try {
                 collector.consume(chunk);
@@ -3119,29 +3217,39 @@ function preparePayload(fileBuf, directory) {
         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);
-    }
+function decompressPayloadSync(payloadCodec, slice, uncompressedLength) {
     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');
+            throw new Error(MSV5_DECOMPRESSED_PAYLOAD_LENGTH_MISMATCH);
+        }
+        return decoded;
+    }
+    if (payloadCodec === CODEC_ZLIB) {
+        const decoded = zlib.inflateSync(slice, {
+            maxOutputLength: MSV5_MAX_UNCOMPRESSED_BYTES,
+        });
+        if (decoded.length !== uncompressedLength) {
+            throw new Error(MSV5_DECOMPRESSED_PAYLOAD_LENGTH_MISMATCH);
         }
-        return sectionsFromPayload(decoded, directory, payloadCrc32);
+        return decoded;
     }
     throw new Error(`MSv5 unknown payload codec ${payloadCodec}`);
 }
+/** 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);
+    }
+    const decoded = decompressPayloadSync(payloadCodec, slice, uncompressedLength);
+    return sectionsFromPayload(decoded, directory, payloadCrc32);
+}
 /** Streaming load; peak main-thread RAM ≈ largest single section (+ file buffer). */
 async function loadMsv5SectionsAsync(fileBuf, directory) {
     const { payloadCodec, slice, uncompressedLength, payloadCrc32 } = preparePayload(fileBuf, directory);
@@ -3154,6 +3262,9 @@ async function loadMsv5SectionsAsync(fileBuf, directory) {
         }
         return loadMsv5SectionsFromZstdStream(slice, directory, uncompressedLength, payloadCrc32);
     }
+    if (payloadCodec === CODEC_ZLIB) {
+        return loadMsv5SectionsFromZlibStream(slice, directory, uncompressedLength, payloadCrc32);
+    }
     throw new Error(`MSv5 unknown payload codec ${payloadCodec}`);
 }
 function isMsv5Buffer(buf) {
@@ -3442,7 +3553,7 @@ function resolvePackedTree(snap, termTree, packedTermIndex) {
     validateTermTreeLeaves(tree, termCount);
     return fromRadixTree(tree, termCount);
 }
-function encodeFrozenSnapshotMsv5(snap, termTree, packedTermIndex) {
+function encodeFrozenSnapshotMsv5(snap, termTree, packedTermIndex, compression) {
     var _a;
     validateFrozenSnapshotNumeric(snap);
     const fieldNames = (_a = snap.fieldNames) !== null && _a !== void 0 ? _a : fieldNamesFromFieldIds(snap.fieldIds);
@@ -3471,9 +3582,9 @@ function encodeFrozenSnapshotMsv5(snap, termTree, packedTermIndex) {
         postingsWire.docIds,
         postingsWire.freqs,
     ];
-    return assembleMsv5File(globalFlags, rawSections).buffer;
+    return assembleMsv5File(globalFlags, rawSections, compression).buffer;
 }
-async function encodeFrozenSnapshotMsv5Async(snap, termTree, packedTermIndex) {
+async function encodeFrozenSnapshotMsv5Async(snap, termTree, packedTermIndex, compression) {
     var _a;
     validateFrozenSnapshotNumeric(snap);
     const fieldNames = (_a = snap.fieldNames) !== null && _a !== void 0 ? _a : fieldNamesFromFieldIds(snap.fieldIds);
@@ -3502,7 +3613,7 @@ async function encodeFrozenSnapshotMsv5Async(snap, termTree, packedTermIndex) {
         postingsWire.docIds,
         postingsWire.freqs,
     ];
-    return (await assembleMsv5FileAsync(globalFlags, rawSections)).buffer;
+    return (await assembleMsv5FileAsync(globalFlags, rawSections, compression)).buffer;
 }
 
 function validateMsv5Container(buf) {
@@ -3579,12 +3690,12 @@ async function decodeFrozenSnapshotMsv5Async(buf, hints) {
 }
 
 /** Encode a frozen snapshot as a binary buffer. */
-function encodeFrozenSnapshot(snap, termTree, packedTermIndex) {
-    return encodeFrozenSnapshotMsv5(snap, termTree, packedTermIndex);
+function encodeFrozenSnapshot(snap, termTree, packedTermIndex, compression) {
+    return encodeFrozenSnapshotMsv5(snap, termTree, packedTermIndex, compression);
 }
-/** Async encoder; uses non-blocking zstd compression for large payloads. */
-function encodeFrozenSnapshotAsync(snap, termTree, packedTermIndex) {
-    return encodeFrozenSnapshotMsv5Async(snap, termTree, packedTermIndex);
+/** Async encoder; uses the selected payload compression without blocking the event loop. */
+function encodeFrozenSnapshotAsync(snap, termTree, packedTermIndex, compression) {
+    return encodeFrozenSnapshotMsv5Async(snap, termTree, packedTermIndex, compression);
 }
 
 const LEGACY_MAGICS = new Set(['MSv1', 'MSv2', 'MSv3', 'MSv4']);
@@ -3601,7 +3712,7 @@ function decodeFrozenSnapshot(buf, hints) {
     }
     throw invalidFrozenIndex('Unsupported frozen binary snapshot');
 }
-/** Async frozen snapshot decode (streaming zstd). */
+/** Async frozen snapshot decode (streaming decompression when needed). */
 async function decodeFrozenSnapshotAsync(buf, hints) {
     assertBufferLength(buf, 8);
     const version = buf.readUInt16LE(4);
@@ -4073,56 +4184,76 @@ function normalizeStringQuery(query, searchOptions, params) {
         ...params.globalSearchOptions,
         ...searchOptions,
     };
-    const terms = options.tokenize(query)
-        .flatMap((term) => options.processTerm(term))
-        .filter(term => !!term);
+    const tokens = options.tokenize(query);
+    const terms = [];
+    for (const token of tokens) {
+        const processed = options.processTerm(token);
+        if (Array.isArray(processed)) {
+            for (const term of processed) {
+                if (term)
+                    terms.push(term);
+            }
+        }
+        else if (processed) {
+            terms.push(processed);
+        }
+    }
+    const toSpec = termToQuerySpec(options);
+    const specs = new Array(terms.length);
+    for (let i = 0; i < terms.length; i++) {
+        specs[i] = toSpec(terms[i], i, terms);
+    }
+    const { fuzzy: fuzzyWeight, prefix: prefixWeight } = {
+        ...defaultSearchOptions.weights,
+        ...options.weights,
+    };
     return {
         options,
-        specs: terms.map(termToQuerySpec(options)),
+        specs,
         operator: options.combineWith,
+        fieldBoosts: fieldBoostsForQuery(options, params.fields),
+        fuzzyWeight,
+        prefixWeight,
     };
 }
 function lazyIndexedTerm(indexView, termIndex) {
     return { kind: 'lazy', resolve: () => indexView.resolveTermByIndex(termIndex) };
 }
-function visitQuerySpecForScoring(query, options, params, visit) {
+function visitQuerySpecForScoring(query, normalized, params, visit) {
     const { indexView } = params;
-    const { weights, maxFuzzy } = options;
-    const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights };
-    const maxDistance = maxFuzzyDistance(query, maxFuzzy);
+    const { fuzzyWeight, options, prefixWeight } = normalized;
+    const maxDistance = maxFuzzyDistance(query, options.maxFuzzy);
     const exactTi = indexView.resolveTermIndex(query.term);
     visit(exactTi == null ? undefined : indexView.fieldTermData(exactTi), query.term, 1);
-    const seenPrefix = new Set();
+    const seenPrefix = query.prefix && maxDistance ? new Set() : undefined;
     if (query.prefix) {
         for (const { termIndex, length } of indexView.getPrefixMatchesByIndex(query.term)) {
             const distance = length - query.term.length;
             if (!distance)
                 continue;
-            seenPrefix.add(termIndex);
+            seenPrefix === null || seenPrefix === void 0 ? void 0 : 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))
+        if (!distance || (seenPrefix === null || seenPrefix === void 0 ? void 0 : 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);
+function executeQuerySpecInternal(query, normalized, params, allowedDocs) {
+    const { fieldBoosts, options } = normalized;
     const termOptions = allowedDocs == null ? undefined : { allowedDocs };
     const results = new Map();
-    visitQuerySpecForScoring(query, options, params, (data, derivedTerm, termWeight) => {
+    visitQuerySpecForScoring(query, normalized, 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);
+function collectDocIdsForQuerySpec(query, normalized, params, allowedDocs) {
+    const { fieldBoosts, options } = normalized;
     const docIds = new Set();
     const { indexView, aggregateContext } = params;
     const maxDistance = maxFuzzyDistance(query, options.maxFuzzy);
@@ -4130,19 +4261,19 @@ function collectDocIdsForQuerySpec(query, searchOptions, params, allowedDocs) {
     if (exactTi != null) {
         indexView.collectDocIds(exactTi, fieldBoosts, aggregateContext, docIds, allowedDocs);
     }
-    const seenPrefix = new Set();
+    const seenPrefix = query.prefix && maxDistance ? new Set() : undefined;
     if (query.prefix) {
         for (const { termIndex, length } of indexView.getPrefixMatchesByIndex(query.term)) {
             const distance = length - query.term.length;
             if (!distance)
                 continue;
-            seenPrefix.add(termIndex);
+            seenPrefix === null || seenPrefix === void 0 ? void 0 : 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))
+            if (!distance || (seenPrefix === null || seenPrefix === void 0 ? void 0 : seenPrefix.has(termIndex)))
                 continue;
             indexView.collectDocIds(termIndex, fieldBoosts, aggregateContext, docIds, allowedDocs);
         }
@@ -4273,14 +4404,15 @@ function collectDocIdsForQueryInternal(query, searchOptions, params, allowedDocs
     if (typeof query !== 'string') {
         throw new Error('FrozenMiniSearch: invalid query');
     }
-    const { options, specs, operator } = normalizeStringQuery(query, searchOptions, params);
+    const normalized = normalizeStringQuery(query, searchOptions, params);
+    const { specs, operator } = normalized;
     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)
+            ? collectDocIdsForQuerySpec(specs[0], normalized, params, allowedDocs)
             : new Set();
     }
-    return collectCombinedDocIds(specs, combineWith, (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, options, params, branchAllowed), allowedDocs);
+    return collectCombinedDocIds(specs, combineWith, (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, normalized, params, branchAllowed), allowedDocs);
 }
 function executeWildcardQuery(searchOptions, params) {
     const results = new Map();
@@ -4310,12 +4442,13 @@ function executeQueryInternal(query, searchOptions, params, allowedDocs, run) {
     if (typeof query !== 'string') {
         throw new Error('FrozenMiniSearch: invalid query');
     }
-    const { options, specs, operator } = normalizeStringQuery(query, searchOptions, params);
+    const normalized = normalizeStringQuery(query, searchOptions, params);
+    const { specs, operator } = normalized;
     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);
+        return executeCombinedBranches(specs, combineWith, params, (spec, branchAllowed) => executeQuerySpecInternal(spec, normalized, params, branchAllowed), (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, normalized, params, branchAllowed), allowedDocs);
     }
-    const results = specs.map(spec => executeQuerySpecInternal(spec, options, params, allowedDocs));
+    const results = specs.map(spec => executeQuerySpecInternal(spec, normalized, params, allowedDocs));
     return combineResults(results, combineWith);
 }
 function executeQuery(query, searchOptions, params) {
@@ -4506,6 +4639,7 @@ function materializeOwnedSnapshot(params, mode) {
 function frozenMemoryBreakdown(frozen) {
     return frozen.memoryBreakdown();
 }
+const noStoredFields = () => undefined;
 function assertFieldsMatchSnapshot(optionsFields, snapFieldIds) {
     const snapNames = Object.keys(snapFieldIds).sort();
     const optNames = [...optionsFields].sort();
@@ -4559,24 +4693,31 @@ class FrozenMiniSearch {
         this._termCount = params.termCount;
         this._postings = params.postings;
         this._fieldTermFlyweight = createFrozenFieldTermFlyweight(this._postings);
+        this._hasStoredFields = this._storedFields.kind !== 'none';
         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 => readStoredFields(this._storedFields, docId),
+            getStoredFields: this._hasStoredFields
+                ? docId => readStoredFields(this._storedFields, docId)
+                : noStoredFields,
         };
         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) => {
-                forEachLiveShortId(this._nextId, this._externalIds, (shortId, id) => {
-                    callback(shortId, id, readStoredFields(this._storedFields, shortId));
-                });
-            }),
+            indexView: createFrozenQueryIndexView(this._index, this._postings, this._fieldTermFlyweight, this._hasStoredFields
+                ? (callback) => {
+                    forEachLiveShortId(this._nextId, this._externalIds, (shortId, id) => {
+                        callback(shortId, id, readStoredFields(this._storedFields, shortId));
+                    });
+                }
+                : (callback) => {
+                    forEachLiveShortId(this._nextId, this._externalIds, callback);
+                }),
             aggregateContext: this._aggregateContext,
         };
     }
@@ -4633,14 +4774,16 @@ class FrozenMiniSearch {
         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 => readStoredFields(this._storedFields, docId));
+        return finalizeRawSearchResults(this.executeQuery(query, searchOptions), query, searchOptions, this._options.searchOptions, docId => this._externalIds[docId], this._hasStoredFields
+            ? docId => readStoredFields(this._storedFields, docId)
+            : undefined);
     }
     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() {
+    saveBinarySync(saveOptions = {}) {
         return encodeFrozenSnapshot({
             documentCount: this._documentCount,
             nextId: this._nextId,
@@ -4654,10 +4797,10 @@ class FrozenMiniSearch {
             fieldLengthMatrix: fieldLengthMatrixForWire(this._fieldLengthMatrix),
             treeShape: [],
             postings: this._postings,
-        }, undefined, this._index);
+        }, undefined, this._index, saveOptions.compression);
     }
-    /** Non-blocking zstd compression; same output as {@link saveBinarySync}. */
-    async saveBinaryAsync() {
+    /** Non-blocking snapshot serialization with the selected compression codec. */
+    async saveBinaryAsync(saveOptions = {}) {
         return encodeFrozenSnapshotAsync({
             documentCount: this._documentCount,
             nextId: this._nextId,
@@ -4671,7 +4814,7 @@ class FrozenMiniSearch {
             fieldLengthMatrix: fieldLengthMatrixForWire(this._fieldLengthMatrix),
             treeShape: [],
             postings: this._postings,
-        }, undefined, this._index);
+        }, undefined, this._index, saveOptions.compression);
     }
     /** Load a frozen binary snapshot. */
     static loadBinarySync(buffer, options = {}) {
@@ -4680,7 +4823,7 @@ class FrozenMiniSearch {
         const snap = decodeFrozenSnapshot(buffer, { storeFields });
         return FrozenMiniSearch.fromBinarySnapshot(snap, options);
     }
-    /** Load a frozen binary snapshot with streaming zstd decompression (bounded memory). */
+    /** Load a frozen binary snapshot with streaming decompression when needed (bounded memory). */
     static async loadBinaryAsync(buffer, options = {}) {
         var _a;
         const storeFields = (_a = options.storeFields) !== null && _a !== void 0 ? _a : defaultFrozenLoadOptions.storeFields;