@delali/narsil 0.2.4-next.54 → 0.2.4-next.59

package/dist/distribution.mjs

@@ -1,24 +1,24 @@
 import { MAX_MESSAGE_SIZE_BYTES } from './chunk-UNEEFTEU.mjs';
-import { validateIndexName, indexConfigKey, putIndexMetadata, getIndexMetadata } from './chunk-NTZYA3SJ.mjs';
-import { createEngineCore, checkHeapAfterRecovery, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, computeEntryChecksum, createEntryMessage, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-BH5SYB5W.mjs';
+import { validateIndexName, indexConfigKey, putIndexMetadata, getIndexMetadata } from './chunk-U7KYW4BA.mjs';
+import { requireKnownConfig, resolveRunnableConfig, createEngineCore, startEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, computeEntryChecksum, createEntryMessage, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-24RXHMEL.mjs';
 import { ReplicationMessageTypes, TransportErrorCodes, ClusterMessageTypes, QueryMessageTypes, TransportError } from './chunk-GCM3JFVA.mjs';
-import { providedDocId, MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR, WIRE_BATCH_BUDGET } from './chunk-4NVPQ6S5.mjs';
-import { generateId, deserializePayloadV2, createPartitionIndex, getLanguage, FILTER_EXPRESSION_KEYS, FIELD_FILTER_OPERATORS } from './chunk-XNQAIO74.mjs';
+import { providedDocId, MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR, WIRE_BATCH_BUDGET } from './chunk-UXNWQZST.mjs';
+import { generateId, deserializePayloadV2, createPartitionIndex, getLanguage, FILTER_EXPRESSION_KEYS, FIELD_FILTER_OPERATORS } from './chunk-ZZT3EAUC.mjs';
 import './chunk-AV4IJKD2.mjs';
-import { now, listBindingOf, queryBindingOf, foldGroupReducer, clampLimit, dedupePinnedEntries } from './chunk-TVT5V4E7.mjs';
-import { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, MAX_INDEX_NAME_LENGTH, MAX_DOC_ID_LENGTH, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, INDEX_NAME_PATTERN } from './chunk-D2S642IV.mjs';
-import { resolveProjection, clampRowCount, sortSignatureOf, requireMatchingCursor, decodePageCursor, normalizeSort, encodePageCursor, applyProjection, readSortValues, requireWithinResultWindow, fnv1a, mergePartitionStats } from './chunk-5T6AOR37.mjs';
-import { DEFAULT_PAGE_SIZE, MAX_SORT_FIELDS, MAX_CURSOR_LENGTH, RESULT_WINDOW, MAX_NESTING_DEPTH } from './chunk-L225SHNB.mjs';
+import { now, listBindingOf, queryBindingOf, hitsKeptPerGroup, clampLimit, resolveHybridFusion, dedupePinnedEntries, foldGroupReducer } from './chunk-B2TFROFX.mjs';
+import { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, MAX_INDEX_NAME_LENGTH, MAX_DOC_ID_LENGTH, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, INDEX_NAME_PATTERN } from './chunk-3LHGNRYE.mjs';
+import { oversampledShardSize, resolveProjection, clampRowCount, sortSignatureOf, requireMatchingCursor, decodePageCursor, normalizeSort, sortModesOf, encodePageCursor, applyProjection, readSortValues, requireWithinResultWindow, fnv1a, sortSignatureEntry, MAX_FILTER_DEPTH, fnv1aUint32s, mergePartitionStats, MIN_POLYGON_POINTS } from './chunk-ZNZBXMP5.mjs';
+import { DEFAULT_PAGE_SIZE, MAX_SORT_FIELDS, MAX_CURSOR_LENGTH, RESULT_WINDOW, MAX_NESTING_DEPTH } from './chunk-L6TNPLAR.mjs';
 import './chunk-TGP5M5R7.mjs';
-import './chunk-U2AL3SON.mjs';
+import './chunk-THYRHHO2.mjs';
 import { MIN_OVERSAMPLE } from './chunk-ZJ4CSAB2.mjs';
-import './chunk-UTOFOJOR.mjs';
+import './chunk-YNVIUGF5.mjs';
 import { crc32 } from './chunk-3L4U6EJQ.mjs';
 import './chunk-IFBKLBGB.mjs';
 import './chunk-U2BKYEC7.mjs';
-import { compareCodePoints, toComparableSortValue, compareComparableKeys, compareSortValues } from './chunk-2GWVQWGA.mjs';
+import { compareCodePoints, toComparableSortValue, compareComparableKeys, isSortMode, SORT_MODES, compareSortValues } from './chunk-YMZCMH5M.mjs';
 import './chunk-POWOTUKJ.mjs';
-import { ErrorCodes, NarsilError, describeError } from './chunk-FRQVMFY7.mjs';
+import { ErrorCodes, NarsilError, describeError } from './chunk-USKFU7J5.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 // src/distribution/cluster/constants.ts
@@ -2515,6 +2515,11 @@ function createDataNodeLifecycle(config) {
   return handle;
 }
 
+// src/distribution/cluster-node/local-index-gone.ts
+function localIndexIsGone(err) {
+  return err instanceof NarsilError && (err.code === ErrorCodes.INDEX_NOT_FOUND || err.code === ErrorCodes.INSTANCE_SHUT_DOWN);
+}
+
 // src/distribution/cluster-node/bootstrap-cleanup.ts
 async function cleanupRemovedPartition(indexName, partitionId, deps) {
   try {
@@ -2530,7 +2535,7 @@ async function cleanupRemovedPartition(indexName, partitionId, deps) {
     if (deps.onError === void 0) {
       return;
     }
-    if (err instanceof NarsilError && err.code === ErrorCodes.INDEX_NOT_FOUND) {
+    if (localIndexIsGone(err)) {
       return;
     }
     const cause = err instanceof Error ? err.message : String(err);
@@ -3311,7 +3316,7 @@ async function dropRestoredIndexQuietly(engine, indexName, deps = {}) {
     }
     await engine.dropIndex(indexName);
   } catch (err) {
-    if (err instanceof NarsilError && err.code === ErrorCodes.INDEX_NOT_FOUND) {
+    if (localIndexIsGone(err)) {
       return;
     }
     if (deps.onError === void 0) {
@@ -3365,7 +3370,7 @@ async function dropExistingIndex(engine, indexName, primaryNodeId) {
     await engine.dropIndex(indexName);
     return null;
   } catch (err) {
-    if (err instanceof NarsilError && err.code === ErrorCodes.INDEX_NOT_FOUND) {
+    if (localIndexIsGone(err)) {
       return null;
     }
     const cause = err instanceof Error ? err.message : String(err);
@@ -5186,20 +5191,15 @@ async function applyLocalReplicationEntry(core, entry) {
 
 // src/distribution/cluster-node/local-engine.ts
 async function createClusterLocalEngine(config, hooks) {
-  const core = createEngineCore(config, hooks);
-  if (core.durability !== null) {
-    await core.durability.manager.recover(config?.lifecycle !== void 0);
-    checkHeapAfterRecovery(core);
-  }
-  if (core.invalidation !== null) {
-    await core.invalidation.start();
-  }
-  if (config?.lifecycle === void 0) await core.analysisRebuild.reviewStaleIndexes();
+  requireKnownConfig(config);
+  const runnableConfig = await resolveRunnableConfig(config);
+  const core = createEngineCore(runnableConfig, hooks);
+  await startEngineCore(core, runnableConfig);
   core.orchestrator.shareMainThread();
-  const engine = createNarsilFromCore(core, config);
+  const engine = createNarsilFromCore(core, runnableConfig);
   const heldPartitions = createHeldPartitionRecord(core);
   return Object.assign(engine, {
-    createIndexWithUuid: (name, indexConfig, indexUuid) => createEngineIndex(core, config, name, indexConfig, indexUuid),
+    createIndexWithUuid: (name, indexConfig, indexUuid) => createEngineIndex(core, runnableConfig, name, indexConfig, indexUuid),
     acquireIndexForReplication: (indexName) => core.indexState.acquire(indexName, false),
     indexUuidOf: (indexName) => core.indexRegistry.get(indexName)?.indexUuid,
     stampIndexUuid: (indexName, indexUuid) => stampIndexUuid(core, indexName, indexUuid),
@@ -6075,8 +6075,8 @@ var MAX_FIELD_NAME_LENGTH = 255;
 var MAX_FIELDS_LIST = 256;
 var MAX_BOOST_FIELDS = 256;
 var MAX_FACETS = 64;
+var MAX_FACET_RANGES = 1e3;
 var MAX_FETCH_DOCUMENT_IDS = 1e4;
-var MAX_FILTER_DEPTH = 30;
 var MAX_FILTER_FIELDS = 256;
 var MAX_FILTER_ARRAY_SIZE = 65536;
 var MAX_FILTER_STRING_LENGTH = 1024;
@@ -6428,6 +6428,13 @@ function validateGeoPolygon(value, fieldLabel, errorCode) {
     throwInvalid(errorCode, `Invalid payload: "${fieldLabel}.points" must be an array`);
   }
   const points = value.points;
+  if (points.length < MIN_POLYGON_POINTS) {
+    throwInvalid(
+      errorCode,
+      `Invalid payload: "${fieldLabel}.points" must hold at least ${MIN_POLYGON_POINTS} points to enclose an area`,
+      { length: points.length, minimum: MIN_POLYGON_POINTS }
+    );
+  }
   if (points.length > MAX_FILTER_ARRAY_SIZE) {
     throwInvalid(
       errorCode,
@@ -6584,13 +6591,9 @@ function validateFilterExpression(value, fieldLabel, errorCode = SEARCH_INVALID_
   }
 }
 
-// src/distribution/query/oversample.ts
-function oversampledShardSize(size) {
-  return Math.ceil(size * 1.5) + 10;
-}
-
 // src/distribution/query/validators/search-options.ts
 var ALLOWED_MODES = ["fulltext", "vector", "hybrid"];
+var ALLOWED_FACET_ORDERS = ["asc", "desc"];
 var ALLOWED_METRICS = ["cosine", "dotProduct", "euclidean"];
 var ALLOWED_HYBRID_STRATEGIES = ["rrf", "linear"];
 function validateHybridParams(value) {
@@ -6643,6 +6646,55 @@ function validateGroupParams(value) {
     );
   }
 }
+function validateFacetRanges(value, fieldLabel) {
+  if (!Array.isArray(value)) {
+    throwInvalid(CONFIG_INVALID, `Invalid SearchPayload: "${fieldLabel}" must be an array or null`);
+  }
+  if (value.length > MAX_FACET_RANGES) {
+    throwInvalid(
+      CONFIG_INVALID,
+      `Invalid SearchPayload: "${fieldLabel}" exceeds maximum length of ${MAX_FACET_RANGES}`,
+      { length: value.length, limit: MAX_FACET_RANGES }
+    );
+  }
+  for (let i = 0; i < value.length; i++) {
+    const range = value[i];
+    if (!isRecord2(range) || typeof range.from !== "number" || typeof range.to !== "number") {
+      throwInvalid(CONFIG_INVALID, `Invalid SearchPayload: "${fieldLabel}[${i}]" must hold a numeric from and to`);
+    }
+  }
+}
+function validateFacetParams(value) {
+  if (!Array.isArray(value)) {
+    throwInvalid(SEARCH_INVALID_FIELD, 'Invalid SearchPayload: "params.facets" must be an array or null');
+  }
+  if (value.length > MAX_FACETS) {
+    throwInvalid(
+      SEARCH_INVALID_FIELD,
+      `Invalid SearchPayload: "params.facets" exceeds maximum length of ${MAX_FACETS}`,
+      {
+        length: value.length,
+        limit: MAX_FACETS
+      }
+    );
+  }
+  for (let i = 0; i < value.length; i++) {
+    const entry = value[i];
+    if (!isRecord2(entry)) {
+      throwInvalid(CONFIG_INVALID, `Invalid SearchPayload: "params.facets[${i}]" must be an object`);
+    }
+    validateFieldName(entry.field, `params.facets[${i}].field`, SEARCH_INVALID_FIELD);
+    if (entry.sort !== null && !ALLOWED_FACET_ORDERS.includes(entry.sort)) {
+      throwInvalid(
+        SEARCH_INVALID_MODE,
+        `Invalid SearchPayload: "params.facets[${i}].sort" must be one of: ${ALLOWED_FACET_ORDERS.join(", ")}, or null`
+      );
+    }
+    if (entry.ranges !== null) {
+      validateFacetRanges(entry.ranges, `params.facets[${i}].ranges`);
+    }
+  }
+}
 function validateTermMatchParam(value) {
   if (value === "all" || value === "any") {
     return;
@@ -6824,6 +6876,12 @@ function validateSortParams(value) {
         `Invalid SearchPayload: "params.sort[${i}].direction" must be one of: ${ALLOWED_SORT_DIRECTIONS.join(", ")}`
       );
     }
+    if (entry.mode !== void 0 && !isSortMode(entry.mode)) {
+      throwInvalid(
+        SEARCH_INVALID_MODE,
+        `Invalid SearchPayload: "params.sort[${i}].mode" must be one of: ${SORT_MODES.join(", ")}`
+      );
+    }
   }
 }
 function validateBoostParams(value) {
@@ -6880,7 +6938,7 @@ function validateParams(params) {
     validateGroupParams(params.group);
   }
   if (params.facets !== null) {
-    validateStringArray(params.facets, "params.facets", MAX_FACETS, 255, SEARCH_INVALID_FIELD);
+    validateFacetParams(params.facets);
   }
   if (params.facetSize !== null) {
     validateNonNegativeInteger(params.facetSize, "params.facetSize", MAX_LIMIT, CONFIG_INVALID);
@@ -7055,6 +7113,12 @@ function validateListSort(value) {
     if (entry.direction !== "asc" && entry.direction !== "desc") {
       throwInvalid(SEARCH_INVALID_MODE, `Invalid ListPayload: "sort[${i}].direction" must be "asc" or "desc"`);
     }
+    if (entry.mode !== void 0 && !isSortMode(entry.mode)) {
+      throwInvalid(
+        SEARCH_INVALID_MODE,
+        `Invalid ListPayload: "sort[${i}].mode" must be one of: ${SORT_MODES.join(", ")}`
+      );
+    }
   }
 }
 function validateListPayload(decoded) {
@@ -7528,6 +7592,13 @@ function createPreflightResultMessage(payload, sourceId, requestId) {
   };
 }
 
+// src/distribution/query/types.ts
+var DEFAULT_QUERY_CONFIG = {
+  allowPartialResults: true,
+  partitionTimeout: 5e3,
+  defaultFacetSize: 10
+};
+
 // src/distribution/cluster-node/query-conversion.ts
 function wireParamsToLocal(wire, facetShardSize) {
   return {
@@ -7590,18 +7661,33 @@ function convertWireSortToLocal(wireSort) {
   if (wireSort === null || wireSort.length === 0) {
     return void 0;
   }
-  return wireSort.map((entry) => ({ field: entry.field, direction: entry.direction }));
+  return normalizeSort(wireSort);
+}
+function countsEveryValue(facet) {
+  return facet.ranges !== null || facet.sort === "asc";
 }
 function convertWireFacetConfigToLocal(facets, limit) {
   if (facets === null || facets.length === 0) {
     return void 0;
   }
   const result = {};
-  for (const field of facets) {
-    result[field] = limit !== null ? { limit } : {};
+  for (const facet of facets) {
+    const options = {};
+    if (countsEveryValue(facet)) options.limit = MAX_FACET_BUCKETS;
+    else if (limit !== null) options.limit = limit;
+    if (facet.sort !== null) options.sort = facet.sort;
+    if (facet.ranges !== null) options.ranges = facet.ranges.map((range) => ({ from: range.from, to: range.to }));
+    result[facet.field] = options;
   }
   return result;
 }
+function ascendingFacetFields(facets) {
+  const ascending = /* @__PURE__ */ new Set();
+  for (const facet of facets ?? []) {
+    if (facet.sort === "asc") ascending.add(facet.field);
+  }
+  return ascending;
+}
 function localParamsToWire(params) {
   return {
     term: params.term ?? null,
@@ -7609,7 +7695,7 @@ function localParamsToWire(params) {
     sort: convertLocalSortToWire(params.sort),
     group: convertLocalGroupToWire(params.group),
     facets: convertLocalFacetsToWire(params.facets),
-    facetSize: null,
+    facetSize: wireFacetSize(params.facets),
     limit: clampRowCount(params.limit, DEFAULT_PAGE_SIZE),
     offset: clampRowCount(params.offset, 0),
     searchAfter: params.searchAfter ?? null,
@@ -7629,7 +7715,19 @@ function localParamsToWire(params) {
     hybrid: convertLocalHybridToWire(params.hybrid)
   };
 }
-function distributedResultToLocal(result, documents = /* @__PURE__ */ new Map()) {
+function countIsExactFor(params) {
+  const vector = params.vector;
+  if (vector === void 0 || vector.value === void 0 && vector.text === void 0) return true;
+  const hasTerm = params.term !== void 0 && params.term.trim().length > 0;
+  if (params.mode === "hybrid" || hasTerm) return false;
+  return vector.similarity === void 0;
+}
+function distributedCountIsExact(params, coverage) {
+  if (coverage.queriedPartitions < coverage.totalPartitions) return false;
+  if (coverage.timedOutPartitions > 0 || coverage.failedPartitions > 0) return false;
+  return countIsExactFor(params);
+}
+function distributedResultToLocal(result, countExact, documents = /* @__PURE__ */ new Map(), requestedFacets) {
   return {
     hits: result.scored.map((entry) => ({
       id: entry.docId,
@@ -7637,9 +7735,10 @@ function distributedResultToLocal(result, documents = /* @__PURE__ */ new Map())
       document: documents.get(entry.docId) ?? {}
     })),
     count: result.totalHits,
+    countExact,
     elapsed: 0,
     cursor: result.cursor ?? void 0,
-    facets: result.facets !== null ? convertWireFacetsToLocal(result.facets, result.facetErrorBounds) : void 0,
+    facets: result.facets !== null ? convertWireFacetsToLocal(result, result.facets, requestedFacets) : void 0,
     coverage: result.coverage
   };
 }
@@ -7653,15 +7752,22 @@ function convertLocalGroupToWire(group) {
   }
   return {
     fields: [...group.fields],
-    maxPerGroup: group.maxPerGroup ?? 1,
+    maxPerGroup: group.reduce !== void 0 ? MAX_LIMIT : hitsKeptPerGroup(group.maxPerGroup),
     limit: group.limit ?? null
   };
 }
+function wireFacetOrder(sort) {
+  return sort === "asc" || sort === "desc" ? sort : null;
+}
 function convertLocalFacetsToWire(facets) {
   if (facets === void 0) {
     return null;
   }
-  return Object.keys(facets);
+  return Object.entries(facets).map(([field, options]) => ({
+    field,
+    sort: wireFacetOrder(options?.sort),
+    ranges: options?.ranges?.map((range) => ({ from: range.from, to: range.to })) ?? null
+  }));
 }
 function convertLocalVectorToWire(vector) {
   if (vector === void 0) {
@@ -7687,18 +7793,34 @@ function convertLocalHybridToWire(hybrid) {
     alpha: hybrid.alpha ?? null
   };
 }
-function convertWireFacetsToLocal(wireFacets, errorBounds) {
-  const result = {};
+function facetLimitOf(options) {
+  const limit = options?.limit;
+  const ranges = options?.ranges;
+  if ((limit === void 0 || !Number.isFinite(limit)) && Array.isArray(ranges)) {
+    return Math.min(Math.max(ranges.length, 1), MAX_FACET_SIZE);
+  }
+  if (limit === void 0 || !Number.isFinite(limit)) return DEFAULT_QUERY_CONFIG.defaultFacetSize;
+  return Math.min(Math.max(Math.floor(limit), 1), MAX_FACET_SIZE);
+}
+function wireFacetSize(facets) {
+  if (facets === void 0) return null;
+  let size = 0;
+  for (const options of Object.values(facets)) size = Math.max(size, facetLimitOf(options));
+  return size === 0 ? null : size;
+}
+function convertWireFacetsToLocal(result, wireFacets, requested) {
+  const converted = {};
   for (const [field, buckets] of Object.entries(wireFacets)) {
+    const mergedBound = result.facetErrorBounds?.[field] ?? 0;
+    const kept = requested === void 0 ? buckets.length : Math.min(buckets.length, facetLimitOf(requested[field]));
     const values = {};
-    let totalCount = 0;
-    for (const bucket of buckets) {
-      values[bucket.value] = bucket.count;
-      totalCount += bucket.count;
-    }
-    result[field] = { values, count: totalCount, errorBound: errorBounds?.[field] ?? 0 };
+    for (let index = 0; index < kept; index++) values[buckets[index].value] = buckets[index].count;
+    let largestCut = 0;
+    for (let index = kept; index < buckets.length; index++) largestCut = Math.max(largestCut, buckets[index].count);
+    const errorBound = kept < buckets.length ? (result.facetUndercounts?.[field] ?? mergedBound) + largestCut : mergedBound;
+    converted[field] = { values, count: kept, errorBound: Math.max(errorBound, mergedBound) };
   }
-  return result;
+  return converted;
 }
 
 // src/distribution/cluster-node/message-handler/queries.ts
@@ -7715,11 +7837,13 @@ async function handleSearch(message, respond, deps) {
     payload.partitionIds,
     payload.globalStats ?? void 0
   );
-  const sortFields = queryParams.sort !== void 0 ? normalizeSort(queryParams.sort).map((entry) => entry.field) : null;
+  const normalizedSort = queryParams.sort !== void 0 ? normalizeSort(queryParams.sort) : null;
+  const sortFields = normalizedSort === null ? null : normalizedSort.map((entry) => entry.field);
+  const sortModes = normalizedSort === null ? [] : sortModesOf(normalizedSort);
   const scored = queryResult.hits.map((hit) => ({
     docId: hit.id,
     score: hit.score ?? null,
-    sortValues: sortFields !== null ? readSortValues(hit.document, sortFields).map(toWireSortValue) : null
+    sortValues: sortFields !== null ? readSortValues(hit.document, sortFields, sortModes).map(toWireSortValue) : null
   }));
   const results = payload.partitionIds.map((partitionId) => ({
     partitionId,
@@ -7730,7 +7854,7 @@ async function handleSearch(message, respond, deps) {
     results,
     facets: convertLocalFacetsToWire2(queryResult.facets),
     facetErrorBounds: convertLocalFacetBoundsToWire(queryResult.facets),
-    groups: await convertLocalGroupsToWire(queryResult.groups, sortFields, deps, payload.indexName)
+    groups: await convertLocalGroupsToWire(queryResult.groups, sortFields, sortModes, deps, payload.indexName)
   };
   await respond({
     type: QueryMessageTypes.SEARCH_RESULT,
@@ -7739,21 +7863,20 @@ async function handleSearch(message, respond, deps) {
     payload: encode(resultPayload)
   });
 }
-async function convertLocalGroupsToWire(groups, sortFields, deps, indexName) {
+async function convertLocalGroupsToWire(groups, sortFields, sortModes, deps, indexName) {
   if (groups === void 0) {
     return null;
   }
+  const unreadIds = sortFields === null ? [] : groups.flatMap((group) => group.hits.filter((hit) => hit.document === void 0).map((hit) => hit.id));
+  const readDocuments = unreadIds.length > 0 ? await deps.engine.getMultiple(indexName, unreadIds) : /* @__PURE__ */ new Map();
   const wireGroups = [];
   for (const group of groups) {
-    const scored = [];
-    for (const hit of group.hits) {
-      let sortValues = null;
-      if (sortFields !== null) {
-        const document = hit.document ?? await deps.engine.get(indexName, hit.id);
-        sortValues = readSortValues(document, sortFields).map(toWireSortValue);
-      }
-      scored.push({ docId: hit.id, score: hit.score ?? null, sortValues });
-    }
+    const scored = group.hits.map((hit) => {
+      if (sortFields === null) return { docId: hit.id, score: hit.score ?? null, sortValues: null };
+      const document = hit.document ?? readDocuments.get(hit.id);
+      const sortValues = readSortValues(document, sortFields, sortModes).map(toWireSortValue);
+      return { docId: hit.id, score: hit.score ?? null, sortValues };
+    });
     wireGroups.push({ values: group.values, scored });
   }
   return wireGroups;
@@ -7843,11 +7966,13 @@ async function handleList(message, respond, deps) {
     document: payload.fields === null ? void 0 : { include: payload.fields }
   };
   const result = await deps.engine.listPartitions(payload.indexName, listParams, payload.partitionIds);
-  const sortFields = payload.sort === null ? null : normalizeSort(payload.sort).map((entry) => entry.field);
+  const normalizedSort = payload.sort === null ? null : normalizeSort(payload.sort);
+  const sortFields = normalizedSort === null ? null : normalizedSort.map((entry) => entry.field);
+  const sortModes = normalizedSort === null ? [] : sortModesOf(normalizedSort);
   const entries = result.documents.map((listed) => ({
     docId: listed.id,
     document: listed.document,
-    sortValues: sortFields === null ? null : readSortValues(listed.document, sortFields).map(toWireSortValue2)
+    sortValues: sortFields === null ? null : readSortValues(listed.document, sortFields, sortModes).map(toWireSortValue2)
   }));
   await respond(
     createListResultMessage(
@@ -9176,7 +9301,7 @@ async function dropLocalCopy(name, engine) {
   try {
     await engine.dropIndex(name);
   } catch (dropError) {
-    if (dropError instanceof NarsilError && dropError.code === ErrorCodes.INDEX_NOT_FOUND) {
+    if (localIndexIsGone(dropError)) {
       return;
     }
     throw dropError;
@@ -9461,6 +9586,30 @@ function createDataNodeHandler(deps) {
 function randomSelector(candidates, _partitionId) {
   return candidates[Math.floor(Math.random() * candidates.length)];
 }
+function queryKeyedSelector(binding) {
+  const queryHash = Number.parseInt(binding, 16) >>> 0;
+  const nodeHashes = /* @__PURE__ */ new Map();
+  function nodeHashOf(nodeId) {
+    let hash = nodeHashes.get(nodeId);
+    if (hash === void 0) {
+      hash = fnv1a(nodeId);
+      nodeHashes.set(nodeId, hash);
+    }
+    return hash;
+  }
+  return (candidates, partitionId) => {
+    let chosen = candidates[0];
+    let highestWeight = -1;
+    for (const candidate of candidates) {
+      const weight = fnv1aUint32s([queryHash, partitionId, nodeHashOf(candidate)]);
+      if (weight > highestWeight) {
+        highestWeight = weight;
+        chosen = candidate;
+      }
+    }
+    return chosen;
+  };
+}
 function collectActiveCandidates(assignment) {
   if (assignment.state !== "ACTIVE") {
     return [];
@@ -9552,11 +9701,12 @@ async function fetchDistributedDocuments(config, nodeId, engine, indexName, resu
   const fields = fetchFieldsFor(projection);
   for (const [targetNodeId, documentIds] of nodeToDocumentIds) {
     if (targetNodeId === nodeId) {
-      for (const { docId } of documentIds) {
-        const document = await engine.get(indexName, docId);
-        if (document !== void 0) {
-          documents.set(docId, applyProjection(document, projection));
-        }
+      const local = await engine.getMultiple(
+        indexName,
+        documentIds.map((ref) => ref.docId)
+      );
+      for (const [docId, document] of local) {
+        documents.set(docId, applyProjection(document, projection));
       }
       continue;
     }
@@ -9619,18 +9769,39 @@ async function readDistributedDocuments(config, nodeId, engine, indexName, docId
       }
       continue;
     }
-    const fetchMessage = createFetchMessage({ indexName, documentIds, fields: null, highlight: null }, nodeId);
-    const response = await sendToNode2(config, targetNodeId, fetchMessage, {
-      message: `Node '${targetNodeId}' did not answer a document fetch for index '${indexName}'`,
-      details: { indexName }
-    });
-    const payload = validateFetchResultPayload(decode(response.payload));
-    for (const fetched of payload.documents) {
-      documents.set(fetched.docId, fetched.document);
+    for (let start = 0; start < documentIds.length; start += MAX_FETCH_DOCUMENT_IDS) {
+      const chunk = documentIds.slice(start, start + MAX_FETCH_DOCUMENT_IDS);
+      const fetchMessage = createFetchMessage({ indexName, documentIds: chunk, fields: null, highlight: null }, nodeId);
+      const response = await sendToNode2(config, targetNodeId, fetchMessage, {
+        message: `Node '${targetNodeId}' did not answer a document fetch for index '${indexName}'`,
+        details: { indexName }
+      });
+      const payload = validateFetchResultPayload(decode(response.payload));
+      for (const fetched of payload.documents) {
+        documents.set(fetched.docId, fetched.document);
+      }
     }
   }
   return documents;
 }
+var QUERY_REJECTION_CODES = /* @__PURE__ */ new Set([
+  ErrorCodes.SEARCH_INVALID_FIELD,
+  ErrorCodes.SEARCH_INVALID_FILTER,
+  ErrorCodes.SEARCH_INVALID_MODE,
+  ErrorCodes.SEARCH_INVALID_CURSOR,
+  ErrorCodes.SEARCH_RESULT_WINDOW_EXCEEDED,
+  ErrorCodes.VECTOR_DIMENSION_MISMATCH,
+  ErrorCodes.CONFIG_INVALID
+]);
+var nodeRejections = /* @__PURE__ */ new WeakSet();
+function queryRejectionOf(response, decoded) {
+  const body = decoded;
+  if (!response.type.endsWith(".error") && body?.error !== true) return null;
+  if (typeof body?.code !== "string" || !QUERY_REJECTION_CODES.has(body.code)) return null;
+  const rejection = new NarsilError(body.code, typeof body.message === "string" ? body.message : body.code);
+  nodeRejections.add(rejection);
+  return rejection;
+}
 async function collectDistributedStats(indexName, params, nodeToPartitions, deps, config) {
   const terms = params.term !== null ? params.term.split(/\s+/).filter((t) => t.length > 0) : [];
   const statsPromises = [];
@@ -9664,6 +9835,7 @@ async function collectDistributedStats(indexName, params, nodeToPartitions, deps
 async function fanOutSearch(indexName, params, globalStats, facetShardSize, nodeToPartitions, deps, config) {
   const nodeEntries = Array.from(nodeToPartitions.entries());
   const promises = [];
+  let rejection = null;
   for (const [nodeId, partitionIds] of nodeEntries) {
     const message = createSearchMessage(
       { indexName, partitionIds, params, globalStats, facetShardSize },
@@ -9683,16 +9855,16 @@ async function fanOutSearch(indexName, params, globalStats, facetShardSize, node
         status: result !== null ? "success" : "timeout",
         results: result
       }),
-      (error) => ({
-        nodeId,
-        partitionIds,
-        status: isTimeoutError(error) ? "timeout" : "failed",
-        results: null
-      })
+      (error) => {
+        if (error instanceof NarsilError && nodeRejections.has(error)) rejection ??= error;
+        return { nodeId, partitionIds, status: isTimeoutError(error) ? "timeout" : "failed", results: null };
+      }
     );
     promises.push(promise);
   }
-  return Promise.all(promises);
+  const outcomes = await Promise.all(promises);
+  if (rejection !== null) throw rejection;
+  return outcomes;
 }
 var OUTCOME_SEVERITY = { success: 0, timeout: 1, failed: 2 };
 function buildCoverage(totalPartitions, unavailablePartitions, ...outcomeSets) {
@@ -9739,6 +9911,8 @@ async function sendWithTimeout(transport, targets, message, timeout, validate) {
   });
   const sendPromise = sendToFirstReachableTarget2(transport, targets, message).then((response) => {
     const decoded = decode(response.payload);
+    const rejection = queryRejectionOf(response, decoded);
+    if (rejection !== null) throw rejection;
     return validate(decoded);
   });
   try {
@@ -9889,9 +10063,10 @@ function popScoredHeap(heap, nodeFirst) {
   }
   return top;
 }
-function mergeDistributedFacets(allFacets, allBounds, maxBuckets = DEFAULT_MAX_FACET_BUCKETS) {
+function mergeDistributedFacets(allFacets, allBounds, maxBuckets = DEFAULT_MAX_FACET_BUCKETS, ascending = /* @__PURE__ */ new Set()) {
   const merged = /* @__PURE__ */ new Map();
   const bounds = /* @__PURE__ */ new Map();
+  const undercounts = {};
   for (const facetMap of allFacets) {
     for (const [field, buckets] of Object.entries(facetMap)) {
       let fieldMap = merged.get(field);
@@ -9917,18 +10092,21 @@ function mergeDistributedFacets(allFacets, allBounds, maxBuckets = DEFAULT_MAX_F
     for (const [value, count] of valueMap) {
       buckets.push({ value, count });
     }
+    const lowestFirst = ascending.has(field);
     buckets.sort((a, b) => {
-      if (a.count !== b.count) return b.count - a.count;
+      if (a.count !== b.count) return lowestFirst ? a.count - b.count : b.count - a.count;
       return compareCodePoints(a.value, b.value);
     });
     facets[field] = buckets.slice(0, maxBuckets);
-    let bound = bounds.get(field) ?? 0;
+    const undercount = bounds.get(field) ?? 0;
+    let largestLeftOut = 0;
     for (let index = maxBuckets; index < buckets.length; index++) {
-      if (buckets[index].count > bound) bound = buckets[index].count;
+      largestLeftOut = Math.max(largestLeftOut, buckets[index].count);
     }
-    errorBounds[field] = bound;
+    undercounts[field] = undercount;
+    errorBounds[field] = undercount + largestLeftOut;
   }
-  return { facets, errorBounds };
+  return { facets, errorBounds, undercounts };
 }
 
 // src/distribution/query/group-merge.ts
@@ -9977,12 +10155,6 @@ function mergeGroupsFor(params, allGroups, sortFields) {
 }
 
 // src/distribution/query/fusion.ts
-function clampAlpha(alpha) {
-  if (!Number.isFinite(alpha)) return 0.5;
-  if (alpha < 0) return 0;
-  if (alpha > 1) return 1;
-  return alpha;
-}
 function compareFusedEntries(a, b) {
   const aScore = a.score ?? 0;
   const bScore = b.score ?? 0;
@@ -9992,7 +10164,7 @@ function compareFusedEntries(a, b) {
   return compareCodePoints(a.docId, b.docId);
 }
 function distributedRRF(lists, options) {
-  const k = options.k > 0 ? options.k : 60;
+  const k = options.k;
   const scores = /* @__PURE__ */ new Map();
   for (const list of lists) {
     for (let rank = 0; rank < list.length; rank++) {
@@ -10073,17 +10245,20 @@ function placePinnedEntries(merged, pinned, depth, allMatchesPresent) {
     }
   }
   const ordered = deduped.sort((a, b) => a.position - b.position);
+  const placedFromOutside = [];
   for (const entry of ordered) {
     if (!allMatchesPresent && entry.position >= depth) continue;
     const organic = removed.get(entry.docId);
+    if (organic === void 0) placedFromOutside.push(entry.docId);
     const placed = { docId: entry.docId, score: 0, sortValues: organic?.sortValues ?? null };
     result.splice(Math.max(0, Math.min(entry.position, result.length)), 0, placed);
   }
-  return result;
+  return { entries: result, placedFromOutside };
 }
 
 // src/distribution/query/hybrid.ts
 async function executeHybridQuery(indexName, params, limit, offset, facetShardSize, facetSize, totalPartitions, routing, deps, config) {
+  const fusion = resolveHybridFusion(params.hybrid);
   const depth = limit + offset;
   const textParams = { ...params, vector: null, hybrid: null, mode: null, limit: depth, offset: 0 };
   const vectorParams = {
@@ -10092,6 +10267,8 @@ async function executeHybridQuery(indexName, params, limit, offset, facetShardSi
     hybrid: null,
     mode: null,
     group: null,
+    facets: null,
+    facetSize: null,
     limit: depth,
     offset: 0
   };
@@ -10144,39 +10321,34 @@ async function executeHybridQuery(indexName, params, limit, offset, facetShardSi
   }
   const mergedText = mergeAndTruncateScoredEntries(textScored, depth);
   const mergedVector = mergeAndTruncateScoredEntries(vectorScored, depth);
-  const hybrid = params.hybrid;
   let fused;
-  if ((hybrid?.strategy ?? "rrf") === "rrf") {
-    fused = distributedRRF([mergedText, mergedVector], { k: hybrid?.k ?? 60 });
+  if (fusion.strategy === "rrf") {
+    fused = distributedRRF([mergedText, mergedVector], { k: fusion.k });
   } else {
-    fused = distributedLinearCombination(mergedText, mergedVector, { alpha: clampAlpha(hybrid?.alpha ?? 0.5) });
+    fused = distributedLinearCombination(mergedText, mergedVector, { alpha: fusion.alpha });
   }
   const allMatchesPresent = coverage.queriedPartitions === coverage.totalPartitions && totalHits <= mergedText.length && mergedVector.length < depth;
-  const fusedWithPinned = params.pinned !== null ? placePinnedEntries(fused, params.pinned, depth, allMatchesPresent) : fused;
-  const truncated = fusedWithPinned.slice(offset, depth);
-  const mergedFacets = allFacets.length > 0 ? mergeDistributedFacets(allFacets, allFacetBounds, facetSize) : null;
+  const placement = params.pinned !== null ? placePinnedEntries(fused, params.pinned, depth, allMatchesPresent) : { entries: fused, placedFromOutside: [] };
+  const truncated = placement.entries.slice(offset, depth);
+  const mergedFacets = allFacets.length > 0 ? mergeDistributedFacets(allFacets, allFacetBounds, facetSize, ascendingFacetFields(params.facets)) : null;
   return {
     scored: truncated,
     totalHits,
     facets: mergedFacets?.facets ?? null,
     facetErrorBounds: mergedFacets?.errorBounds ?? null,
+    facetUndercounts: mergedFacets?.undercounts ?? null,
     groups: mergeGroupsFor(params, allGroups, null),
     cursor: null,
-    coverage
+    coverage,
+    pinnedFromOutside: placement.placedFromOutside,
+    mergeHeldEveryMatch: allMatchesPresent
   };
 }
 
-// src/distribution/query/types.ts
-var DEFAULT_QUERY_CONFIG = {
-  allowPartialResults: true,
-  partitionTimeout: 5e3,
-  defaultFacetSize: 10
-};
-
 // src/distribution/query/routing.ts
 function wireSortSignature(sort) {
   if (sort === null || sort.length === 0) return null;
-  return JSON.stringify(sort.map((field) => [field.field, field.direction]));
+  return JSON.stringify(sort.map(sortSignatureEntry));
 }
 function resolveAndClampFacetSize(paramsFacetSize, configDefault) {
   const raw = paramsFacetSize !== null && Number.isFinite(paramsFacetSize) && Number.isInteger(paramsFacetSize) ? paramsFacetSize : configDefault;
@@ -10215,7 +10387,7 @@ async function distributedQuery(indexName, params, deps, config, selector) {
       coverage: { totalPartitions: 0, queriedPartitions: 0, timedOutPartitions: 0, failedPartitions: 0 }
     };
   }
-  const routing = selectReplicasForQuery(allocationTable, randomSelector);
+  const routing = selectReplicasForQuery(allocationTable, queryKeyedSelector(binding));
   const totalPartitions = allocationTable.assignments.size;
   if (routing.unavailablePartitions.length > 0 && !resolvedConfig.allowPartialResults) {
     throw new NarsilError(
@@ -10323,24 +10495,28 @@ async function executeSingleFanOut(indexName, params, binding, limit, offset, fa
     sortFields.map((field) => field.direction)
   ) : mergeAndTruncateScoredEntries(allScored, depth);
   const allMatchesPresent = coverage.queriedPartitions === coverage.totalPartitions && totalHits <= merged.length;
-  const placed = params.pinned !== null && params.searchAfter === null ? placePinnedEntries(merged, params.pinned, depth, allMatchesPresent) : merged;
-  const mergedScored = placed.slice(offset, depth);
-  const mergedFacets = allFacets.length > 0 ? mergeDistributedFacets(allFacets, allFacetBounds, facetSize) : null;
+  const placement = params.pinned !== null && params.searchAfter === null ? placePinnedEntries(merged, params.pinned, depth, allMatchesPresent) : { entries: merged, placedFromOutside: [] };
+  const mergedScored = placement.entries.slice(offset, depth);
+  const mergedFacets = allFacets.length > 0 ? mergeDistributedFacets(allFacets, allFacetBounds, facetSize, ascendingFacetFields(params.facets)) : null;
   const mergedGroups = mergeGroupsFor(params, allGroups, sortFields);
   let cursor = null;
   const lastEntry = lastOrganicEntry(mergedScored, params.searchAfter === null ? params.pinned : null);
+  const reachedDepth = params.searchAfter === null ? 0 : decodePageCursor(params.searchAfter).depth ?? 0;
+  const nextDepth = reachedDepth + offset + mergedScored.length;
   if (lastEntry !== void 0) {
     cursor = sortFields !== null ? encodePageCursor({
       anchor: lastEntry.docId,
       score: null,
       sortKey: (lastEntry.sortValues ?? []).map(toComparableSortValue),
       sortSignature: wireSortSignature(sortFields),
+      depth: nextDepth,
       binding
     }) : encodePageCursor({
       anchor: lastEntry.docId,
       score: lastEntry.score,
       sortKey: null,
       sortSignature: null,
+      depth: nextDepth,
       binding
     });
   }
@@ -10349,9 +10525,12 @@ async function executeSingleFanOut(indexName, params, binding, limit, offset, fa
     totalHits,
     facets: mergedFacets?.facets ?? null,
     facetErrorBounds: mergedFacets?.errorBounds ?? null,
+    facetUndercounts: mergedFacets?.undercounts ?? null,
     groups: mergedGroups,
     cursor,
-    coverage
+    coverage,
+    pinnedFromOutside: placement.placedFromOutside,
+    mergeHeldEveryMatch: allMatchesPresent
   };
 }
 function failOutcomesMissingSortValues(outcomes) {
@@ -10374,28 +10553,44 @@ async function assembleDistributedGroups(deps, indexName, params, distributed, a
   }
   const reduce = group.reduce;
   const needsDocuments = reduce !== void 0 || projection.kind !== "none";
-  const groupDocIds = [...new Set(wireGroups.flatMap((entry) => entry.scored.map((scored) => scored.docId)))];
-  const documents = needsDocuments && groupDocIds.length > 0 ? await readDistributedDocuments(deps.config, deps.nodeId, deps.engine, indexName, groupDocIds, allocation) : /* @__PURE__ */ new Map();
-  return wireGroups.map((entry) => {
-    const hits = entry.scored.map((scored) => ({
-      id: scored.docId,
-      score: scored.score ?? void 0,
-      document: projectedGroupDocument(documents.get(scored.docId), projection)
-    }));
-    const result = { values: entry.values, hits };
-    if (reduce !== void 0) {
-      const folded = foldGroupReducer(
-        reduce,
-        entry.scored.map((scored) => ({ document: documents.get(scored.docId), score: scored.score ?? 0 }))
-      );
-      if (folded.reducerError !== void 0) {
-        result.reducerError = folded.reducerError;
-      } else {
-        result.reduced = folded.reduced;
-      }
-    }
-    return result;
-  });
+  const keptPerGroup = hitsKeptPerGroup(group.maxPerGroup);
+  const docIdsRead = (entry) => (reduce === void 0 ? entry.scored.slice(0, keptPerGroup) : entry.scored).map((scored) => scored.docId);
+  const results = [];
+  let batch = [];
+  let batchDocIds = /* @__PURE__ */ new Set();
+  async function assembleBatch() {
+    const documents = needsDocuments && batchDocIds.size > 0 ? await readDistributedDocuments(deps.config, deps.nodeId, deps.engine, indexName, [...batchDocIds], allocation) : /* @__PURE__ */ new Map();
+    for (const entry of batch) results.push(assembleGroup(entry, documents, keptPerGroup, projection, reduce));
+    batch = [];
+    batchDocIds = /* @__PURE__ */ new Set();
+  }
+  for (const entry of wireGroups) {
+    const docIds = docIdsRead(entry);
+    if (batch.length > 0 && batchDocIds.size + docIds.length > MAX_FETCH_DOCUMENT_IDS) await assembleBatch();
+    batch.push(entry);
+    for (const docId of docIds) batchDocIds.add(docId);
+  }
+  if (batch.length > 0) await assembleBatch();
+  return results;
+}
+function assembleGroup(entry, documents, keptPerGroup, projection, reduce) {
+  const hits = entry.scored.slice(0, keptPerGroup).map((scored) => ({
+    id: scored.docId,
+    score: scored.score ?? void 0,
+    document: projectedGroupDocument(documents.get(scored.docId), projection)
+  }));
+  const result = { values: entry.values, hits };
+  if (reduce === void 0) return result;
+  const folded = foldGroupReducer(
+    reduce,
+    entry.scored.map((scored) => ({ document: documents.get(scored.docId), score: scored.score ?? 0 }))
+  );
+  if (folded.reducerError !== void 0) {
+    result.reducerError = folded.reducerError;
+  } else {
+    result.reduced = folded.reduced;
+  }
+  return result;
 }
 function projectedGroupDocument(document, projection) {
   if (document === void 0 || projection.kind === "none") {
@@ -10421,17 +10616,31 @@ function splitPinnedByReachability(pinnedIds, allocation) {
   }
   return { verifiable, unverifiable };
 }
-async function dropUnstoredPinnedEntries(deps, indexName, params, distributed, allocation, projection, documents) {
-  if (params.pinned === void 0 || params.searchAfter !== void 0) {
-    return distributed.scored;
-  }
+async function readPinPresence(deps, indexName, params, allocation) {
+  if (params.pinned === void 0 || params.searchAfter !== void 0) return null;
   const pinnedIds = new Set(params.pinned.map((entry) => entry.docId));
   const { verifiable, unverifiable } = splitPinnedByReachability(pinnedIds, allocation);
-  const stored = projection.kind === "none" ? await readDistributedDocuments(deps.config, deps.nodeId, deps.engine, indexName, verifiable, allocation) : documents;
+  const documents = verifiable.length === 0 ? /* @__PURE__ */ new Map() : await readDistributedDocuments(deps.config, deps.nodeId, deps.engine, indexName, verifiable, allocation);
+  return { pinnedIds, stored: new Set(documents.keys()), unverifiable };
+}
+function dropUnstoredPinnedEntries(distributed, presence) {
+  if (presence === null) return distributed.scored;
   return distributed.scored.filter(
-    (entry) => !pinnedIds.has(entry.docId) || unverifiable.has(entry.docId) || stored.has(entry.docId)
+    (entry) => !presence.pinnedIds.has(entry.docId) || presence.unverifiable.has(entry.docId) || presence.stored.has(entry.docId)
   );
 }
+function countStoredPinsFromOutside(distributed, presence) {
+  const outside = distributed.pinnedFromOutside ?? [];
+  if (outside.length === 0) return { stored: 0, everyPinVerified: true };
+  if (presence === null) return { stored: 0, everyPinVerified: false };
+  let count = 0;
+  let everyPinVerified = true;
+  for (const docId of outside) {
+    if (presence.unverifiable.has(docId)) everyPinVerified = false;
+    else if (presence.stored.has(docId)) count++;
+  }
+  return { stored: count, everyPinVerified };
+}
 function strictScatterGroups(allocation, indexName) {
   const routing = selectReplicasForQuery(allocation, randomSelector);
   if (routing.unavailablePartitions.length > 0) {
@@ -10581,7 +10790,7 @@ function toWireSortValue3(value) {
   if (typeof value === "boolean") return value;
   return null;
 }
-async function gatherLocalPage(deps, indexName, payload, partitionIds, sortFieldNames) {
+async function gatherLocalPage(deps, indexName, payload, partitionIds, sortFieldNames, sortModes) {
   const listParams = {
     cursor: payload.cursor ?? void 0,
     limit: payload.limit,
@@ -10593,7 +10802,7 @@ async function gatherLocalPage(deps, indexName, payload, partitionIds, sortField
   const entries = result.documents.map((listed) => ({
     docId: listed.id,
     document: listed.document,
-    sortValues: sortFieldNames === null ? null : readSortValues(listed.document, sortFieldNames).map(toWireSortValue3)
+    sortValues: sortFieldNames === null ? null : readSortValues(listed.document, sortFieldNames, sortModes).map(toWireSortValue3)
   }));
   return { entries, total: result.total, hasMore: result.cursor !== null };
 }
@@ -10632,7 +10841,8 @@ async function listCluster(deps, indexName, params) {
           indexName,
           { ...payload, partitionIds: group.partitionIds },
           group.partitionIds,
-          sortFieldNames
+          sortFieldNames,
+          sortModesOf(normalizedSort)
         );
       }
       const message = createListMessage({ ...payload, partitionIds: group.partitionIds }, deps.nodeId);
@@ -10757,7 +10967,11 @@ async function preflightCluster(deps, indexName, params) {
     count += result2.count;
     analysisStale = analysisStale || result2.analysisStale;
   }
-  const result = { count, elapsed: performance.now() - startTime };
+  const result = {
+    count,
+    countExact: countIsExactFor(params),
+    elapsed: performance.now() - startTime
+  };
   if (analysisStale) {
     result.analysisStale = true;
   }
@@ -10808,16 +11022,22 @@ async function queryCluster(deps, indexName, params) {
     allocation,
     projection
   );
-  const scored = await dropUnstoredPinnedEntries(
-    deps,
-    indexName,
-    params,
-    distributed,
-    allocation,
-    projection,
-    documents
+  const pinPresence = await readPinPresence(deps, indexName, params, allocation);
+  const scored = dropUnstoredPinnedEntries(distributed, pinPresence);
+  const pins = countStoredPinsFromOutside(distributed, pinPresence);
+  let countExact = distributedCountIsExact(params, distributed.coverage);
+  let totalHits = distributed.totalHits;
+  if (distributed.mergeHeldEveryMatch === true && pins.everyPinVerified) {
+    totalHits += pins.stored;
+  } else if (pins.stored > 0 || !pins.everyPinVerified) {
+    countExact = false;
+  }
+  const result = distributedResultToLocal(
+    { ...distributed, scored, totalHits },
+    countExact,
+    documents,
+    params.facets
   );
-  const result = distributedResultToLocal({ ...distributed, scored }, documents);
   const groups = await assembleDistributedGroups(deps, indexName, params, distributed, allocation, projection);
   if (groups !== void 0) {
     result.groups = groups;