@delali/narsil 0.2.4-next.55 → 0.3.0

package/dist/{chunk-XNQAIO74.mjs → chunk-ZZT3EAUC.mjs}

@@ -1,12 +1,12 @@
 import { detectRuntime } from './chunk-AV4IJKD2.mjs';
-import { cloneProjected, mergeFacets, visitTokens, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, projectionKeepsField, setNestedValue, fnv1a, bitsetHas, createBitSet, kWayMerge, boundedLevenshtein, bitsetSet, tokenize, bitsetFromSet, tokenizeIterator, bitsetAnd, bitsetOr, bitsetNot } from './chunk-5T6AOR37.mjs';
-import { flattenSchema, validateDocument, validateDocumentStrict, isQuantizationMode, isStorageMode, extractVectorFieldsFromSchema, isTextFieldType, VECTOR_PATTERN } from './chunk-L225SHNB.mjs';
+import { cloneProjected, everyValueFacetConfig, mergeFacets, computeFacets, tokenizeOptions, getNestedValue, visitTokens, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, getFlatSchema, textFieldsChanged, projectionKeepsField, setNestedValue, fnv1a, bitsetHas, createBitSet, kWayMerge, boundedLevenshtein, bitsetSet, tokenize, bitsetFromSet, getAllInternalDocIds, getFieldValueByInternalId, getOrCreateFieldNameIndex, tokenizeIterator, polygonContainment, requireValidOperands, bitsetAnd, bitsetOr, bitsetNot, requirePolygonRing, VINCENTY_CONVERGENCE_THRESHOLD, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-ZNZBXMP5.mjs';
+import { flattenSchema, validateDocument, validateDocumentStrict, isQuantizationMode, isStorageMode, extractVectorFieldsFromSchema, isTextFieldType, VECTOR_PATTERN } from './chunk-L6TNPLAR.mjs';
 import { english } from './chunk-TGP5M5R7.mjs';
-import { SCRATCH_SLOTS_PER_THREAD_POOL, osqRecordBytes, openSharedVectorField, osqBitsOf, createVectorStore, DISK_STORAGE_BLOCK_BYTES, createOsqQuantizer, magnitude, createHNSWIndex, nativeStoreScratchBytes, createOrdinalFilter, addToOrdinalFilter, ordinalFilterValues, isTombstoned, nativeScoresOf, toScore, removeFromOrdinalFilter, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, requireWholeNeighbourLists, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, releaseLocksHeldBy, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS } from './chunk-U2AL3SON.mjs';
-import { noteFallback } from './chunk-UTOFOJOR.mjs';
+import { SCRATCH_SLOTS_PER_THREAD_POOL, osqRecordBytes, openSharedVectorField, osqBitsOf, createVectorStore, DISK_STORAGE_BLOCK_BYTES, createOsqQuantizer, magnitude, createHNSWIndex, nativeStoreScratchBytes, createOrdinalFilter, isTombstoned, addToOrdinalFilter, ordinalFilterValues, nativeScoresOf, toScore, removeFromOrdinalFilter, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, requireWholeNeighbourLists, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, releaseLocksHeldBy, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS } from './chunk-THYRHHO2.mjs';
+import { noteFallback } from './chunk-YNVIUGF5.mjs';
 import { VALID_HNSW_METRICS } from './chunk-IFBKLBGB.mjs';
-import { compareCodePoints, toComparableSortValue, readSortField, compareComparableValues, SORT_VALUE_MAX_CODE_POINTS } from './chunk-2GWVQWGA.mjs';
-import { NarsilError, ErrorCodes } from './chunk-FRQVMFY7.mjs';
+import { compareCodePoints, toReducedSortValue, readSortField, compareComparableValues, defaultSortMode, SORT_VALUE_MAX_CODE_POINTS } from './chunk-YMZCMH5M.mjs';
+import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
 import { totalmem } from 'os';
 import { getHeapStatistics } from 'v8';
 import { encode, decode } from '@msgpack/msgpack';
@@ -1415,215 +1415,6 @@ function createSurfaceRegistry() {
   };
 }
 
-// src/core/partition/utils.ts
-function getOrCreateFieldNameIndex(table, fieldName) {
-  const existing = table.indexMap.get(fieldName);
-  if (existing !== void 0) return existing;
-  const idx = table.names.length;
-  table.names.push(fieldName);
-  table.indexMap.set(fieldName, idx);
-  return idx;
-}
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (let i = 0; i < parts.length; i++) {
-    if (current === null || current === void 0 || typeof current !== "object") return void 0;
-    current = current[parts[i]];
-  }
-  return current;
-}
-function stringArraysEqual(a, b) {
-  if (a === b) return true;
-  if (!a || !b) return false;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
-function textFieldsChanged(oldDoc, newDoc, flatSchema) {
-  for (const [path, fieldType] of Object.entries(flatSchema)) {
-    if (!isTextFieldType(fieldType) && fieldType !== "string[]") continue;
-    const oldVal = getNestedValue(oldDoc, path);
-    const newVal = getNestedValue(newDoc, path);
-    if (fieldType !== "string[]") {
-      if (oldVal !== newVal) return true;
-    } else {
-      if (!stringArraysEqual(oldVal, newVal)) return true;
-    }
-  }
-  return false;
-}
-function tokenizeOptions(options) {
-  return {
-    stem: true,
-    removeStopWords: true,
-    collectSurfaces: options?.collectSurfaces === true,
-    stopWordOverride: options?.stopWordOverride,
-    customTokenizer: options?.customTokenizer
-  };
-}
-function getFlatSchema(state, schema) {
-  if (state.lastSchemaRef === schema && state.flatSchemaCache) return state.flatSchemaCache;
-  state.flatSchemaCache = flattenSchema(schema);
-  state.lastSchemaRef = schema;
-  return state.flatSchemaCache;
-}
-function getFieldValueForDoc(docStore, docId, fieldPath) {
-  const stored = docStore.get(docId);
-  if (!stored) return void 0;
-  return getNestedValue(stored.fields, fieldPath);
-}
-function getFieldValueByInternalId(docStore, internalId, fieldPath) {
-  const externalId = docStore.getExternalId(internalId);
-  if (externalId === void 0) return void 0;
-  return getFieldValueForDoc(docStore, externalId, fieldPath);
-}
-function getAllInternalDocIds(docStore) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const internalId of docStore.allInternalIds()) {
-    ids.add(internalId);
-  }
-  return ids;
-}
-
-// src/core/partition/facets.ts
-function ordinalBitsetOf(state, matched) {
-  if ("ordinalBitset" in matched) return matched.ordinalBitset;
-  const bitset = createBitSet(state.docStore.internalIdCapacity());
-  for (const docId of matched) {
-    const ordinal = state.docStore.getInternalId(docId);
-    if (ordinal !== void 0) bitsetSet(bitset, ordinal);
-  }
-  return bitset;
-}
-function* matchedFieldValues(state, fieldPath, matched) {
-  if ("ordinalBitset" in matched) {
-    const bits = matched.ordinalBitset;
-    for (let wordIndex = 0; wordIndex < bits.length; wordIndex++) {
-      let word = bits[wordIndex];
-      if (word === 0) continue;
-      const base = wordIndex << 5;
-      while (word !== 0) {
-        const trailingZeros = Math.clz32(word & -word) ^ 31;
-        yield getFieldValueByInternalId(state.docStore, base + trailingZeros, fieldPath);
-        word &= word - 1;
-      }
-    }
-    return;
-  }
-  for (const docId of matched) {
-    yield getFieldValueForDoc(state.docStore, docId, fieldPath);
-  }
-}
-function countValuesFromDocuments(state, fieldPath, matched) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const value of matchedFieldValues(state, fieldPath, matched)) {
-    if (value === void 0 || value === null) continue;
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        const key = String(item);
-        counts.set(key, (counts.get(key) ?? 0) + 1);
-      }
-    } else {
-      const key = String(value);
-      counts.set(key, (counts.get(key) ?? 0) + 1);
-    }
-  }
-  return counts;
-}
-function countRangeFromDocuments(state, fieldPath, fieldType, range, matched) {
-  let count = 0;
-  for (const value of matchedFieldValues(state, fieldPath, matched)) {
-    if (fieldType === "number[]" && Array.isArray(value)) {
-      for (const v of value) {
-        if (v >= range.from && v < range.to) {
-          count++;
-          break;
-        }
-      }
-    } else if (typeof value === "number" && value >= range.from && value < range.to) {
-      count++;
-    }
-  }
-  return count;
-}
-function countNumericRanges(state, fieldPath, fieldType, ranges, bitset, matched) {
-  const counts = /* @__PURE__ */ new Map();
-  const index = state.numericIndexes.get(fieldPath);
-  for (const range of ranges) {
-    const label = `${range.from}-${range.to}`;
-    if (index === void 0) {
-      counts.set(label, countRangeFromDocuments(state, fieldPath, fieldType, range, matched));
-    } else if (Number.isNaN(range.from) || Number.isNaN(range.to)) {
-      counts.set(label, 0);
-    } else {
-      counts.set(label, index.facetRangeCount(range.from, range.to, bitset()));
-    }
-  }
-  return counts;
-}
-function countFieldValues(state, fieldPath, fieldType, bitset, matched) {
-  if (fieldType === "enum" || fieldType === "enum[]") {
-    const index = state.enumIndexes.get(fieldPath);
-    if (index !== void 0) return index.facetCounts(bitset());
-  } else if (fieldType === "boolean" || fieldType === "boolean[]") {
-    const index = state.booleanIndexes.get(fieldPath);
-    if (index !== void 0) {
-      const { trueCount, falseCount } = index.facetCounts(bitset());
-      const counts = /* @__PURE__ */ new Map();
-      if (trueCount > 0) counts.set("true", trueCount);
-      if (falseCount > 0) counts.set("false", falseCount);
-      return counts;
-    }
-  } else if (fieldType === "number" || fieldType === "number[]") {
-    const index = state.numericIndexes.get(fieldPath);
-    if (index !== void 0) {
-      const counts = /* @__PURE__ */ new Map();
-      for (const [value, count] of index.facetValueCounts(bitset())) {
-        counts.set(String(value), count);
-      }
-      return counts;
-    }
-  }
-  return countValuesFromDocuments(state, fieldPath, matched);
-}
-function computeFacets(state, matched, config, schema) {
-  const result = {};
-  const flatSchema = getFlatSchema(state, schema);
-  let matchedBitset = null;
-  const bitset = () => {
-    if (matchedBitset === null) matchedBitset = ordinalBitsetOf(state, matched);
-    return matchedBitset;
-  };
-  for (const [fieldPath, facetOpts] of Object.entries(config)) {
-    const fieldType = flatSchema[fieldPath];
-    if (!fieldType) continue;
-    const valueCounts = facetOpts.ranges && (fieldType === "number" || fieldType === "number[]") ? countNumericRanges(state, fieldPath, fieldType, facetOpts.ranges, bitset, matched) : countFieldValues(state, fieldPath, fieldType, bitset, matched);
-    const ordered = Array.from(valueCounts.entries());
-    const sortDir = facetOpts.sort ?? "desc";
-    ordered.sort((a, b) => (sortDir === "asc" ? a[1] - b[1] : b[1] - a[1]) || compareCodePoints(a[0], b[0]));
-    const keep = facetOpts.limit && facetOpts.limit > 0 ? facetOpts.limit : ordered.length;
-    const entries = ordered.slice(0, keep);
-    let errorBound = 0;
-    for (let index = keep; index < ordered.length; index++) {
-      if (ordered[index][1] > errorBound) errorBound = ordered[index][1];
-    }
-    const values = {};
-    for (const [key, count] of entries) {
-      values[key] = count;
-    }
-    result[fieldPath] = { values, count: entries.length, errorBound };
-  }
-  return result;
-}
-
-// src/geo/constants.ts
-var DEG_TO_RAD = Math.PI / 180;
-var VINCENTY_MAX_ITERATIONS = 200;
-var VINCENTY_CONVERGENCE_THRESHOLD = 1e-12;
-
 // src/geo/haversine.ts
 var EARTH_RADIUS_METERS = 63710088e-1;
 function haversineDistance(lat1, lon1, lat2, lon2) {
@@ -1638,27 +1429,6 @@ function haversineDistance(lat1, lon1, lat2, lon2) {
   return EARTH_RADIUS_METERS * c;
 }
 
-// src/geo/polygon.ts
-function isPointInPolygon(lat, lon, polygon) {
-  if (polygon.length < 3) return false;
-  let inside = false;
-  const n = polygon.length;
-  for (let i = 0, j = n - 1; i < n; j = i++) {
-    const lonI = polygon[i].lon;
-    const latI = polygon[i].lat;
-    const lonJ = polygon[j].lon;
-    const latJ = polygon[j].lat;
-    if (lonI > lon !== lonJ > lon) {
-      const slope = (latJ - latI) / (lonJ - lonI);
-      const intersectLat = latI + slope * (lon - lonI);
-      if (lat < intersectLat) {
-        inside = !inside;
-      }
-    }
-  }
-  return inside;
-}
-
 // src/geo/vincenty.ts
 var WGS84_A = 6378137;
 var WGS84_F = 1 / 298.257223563;
@@ -1741,9 +1511,10 @@ function createGeoIndex() {
     },
     polygonQuery(points, inside) {
       const result = /* @__PURE__ */ new Set();
+      const contains = polygonContainment(points);
       for (let i = 0; i < entries.length; i++) {
         const entry = entries[i];
-        const withinPolygon = isPointInPolygon(entry.lat, entry.lon, points);
+        const withinPolygon = contains(entry.lat, entry.lon);
         if (inside ? withinPolygon : !withinPolygon) {
           result.add(entry.docId);
         }
@@ -2510,7 +2281,12 @@ var METERS_PER_MI = 1609.344;
 function convertToMeters(distance, unit) {
   if (unit === "km") return distance * METERS_PER_KM;
   if (unit === "mi") return distance * METERS_PER_MI;
-  return distance;
+  if (unit === "m") return distance;
+  throw new NarsilError(
+    ErrorCodes.SEARCH_INVALID_FILTER,
+    `The engine measures a radius in "km", "mi", or "m", and "${String(unit)}" is none of them`,
+    { unit: String(unit) }
+  );
 }
 function matchesNumericComparison(value, filter) {
   if (filter.eq !== void 0 && value !== filter.eq) return false;
@@ -2522,6 +2298,27 @@ function matchesNumericComparison(value, filter) {
   if (filter.between !== void 0 && !(value >= filter.between[0] && value <= filter.between[1])) return false;
   return true;
 }
+function holdsValue(stored, value) {
+  return Array.isArray(stored) ? stored.includes(value) : stored === value;
+}
+function lacksValue(stored, value) {
+  if (stored === void 0 || stored === null) return false;
+  return Array.isArray(stored) ? !stored.includes(value) : stored !== value;
+}
+function isStringIn(values) {
+  return (element) => typeof element === "string" && values.has(element);
+}
+function holdsStringIn(stored, values) {
+  return Array.isArray(stored) ? stored.some(isStringIn(values)) : isStringIn(values)(stored);
+}
+function holdsNoStringIn(stored, values) {
+  if (Array.isArray(stored)) return !stored.some(isStringIn(values));
+  return typeof stored === "string" && !values.has(stored);
+}
+function holdsStringWhere(stored, test) {
+  const matches = (element) => typeof element === "string" && test(element);
+  return Array.isArray(stored) ? stored.some(matches) : matches(stored);
+}
 
 // src/filters/operators/bitset.ts
 function resolveBitset(bs) {
@@ -2555,7 +2352,7 @@ function applyEqBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
   if (fieldIndex?.type === "enum" && typeof value === "string") {
     return fieldIndex.index.getDocIdsBitset(value, capacity);
   }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v === value);
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsValue(v, value));
 }
 function applyNeBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
   if (fieldIndex?.type === "numeric" && typeof value === "number") {
@@ -2571,7 +2368,7 @@ function applyNeBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
     const eq = fieldIndex.index.getDocIdsBitset(value, capacity);
     return bitsetAnd(all, bitsetNot(eq, capacity));
   }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v !== void 0 && v !== null && v !== value);
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => lacksValue(v, value));
 }
 function applyGtBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
   if (fieldIndex?.type === "numeric") {
@@ -2608,7 +2405,7 @@ function applyInBitset(values, allDocsBitset, capacity, getValue, fieldIndex) {
     return fieldIndex.index.getDocIdsInBitset(values, capacity);
   }
   const valSet = new Set(values);
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "string" && valSet.has(v));
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsStringIn(v, valSet));
 }
 function applyNinBitset(values, allDocsBitset, capacity, getValue, fieldIndex) {
   if (fieldIndex?.type === "enum") {
@@ -2617,18 +2414,13 @@ function applyNinBitset(values, allDocsBitset, capacity, getValue, fieldIndex) {
     return bitsetAnd(all, bitsetNot(matched, capacity));
   }
   const valSet = new Set(values);
-  return scanToBitset(
-    allDocsBitset,
-    capacity,
-    getValue,
-    (v) => v !== void 0 && v !== null && typeof v === "string" && !valSet.has(v)
-  );
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsNoStringIn(v, valSet));
 }
 function applyStartsWithBitset(prefix, allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "string" && v.startsWith(prefix));
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsStringWhere(v, (text) => text.startsWith(prefix)));
 }
 function applyEndsWithBitset(suffix, allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "string" && v.endsWith(suffix));
+  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsStringWhere(v, (text) => text.endsWith(suffix)));
 }
 function applyContainsAllBitset(values, allDocsBitset, capacity, getValue) {
   return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
@@ -2692,6 +2484,7 @@ function applyGeoRadiusBitset(filter, geoIndex, capacity) {
   return bitsetFromSet(setResult, capacity);
 }
 function applyGeoPolygonBitset(filter, geoIndex, capacity) {
+  requirePolygonRing(filter.points);
   const setResult = geoIndex.polygonQuery(filter.points, filter.inside ?? true);
   return bitsetFromSet(setResult, capacity);
 }
@@ -2741,9 +2534,10 @@ function evaluateFieldFilter(fieldPath, filter, context) {
     OPERATOR_KEYS,
     (key) => `Field "${fieldPath}" is tested with "${key}", which is no filter operator`
   );
+  const f = filter;
+  requireValidOperands(fieldPath, f, context.fieldTypes[fieldPath]);
   const fieldIndex = context.fieldIndexes[fieldPath];
   const getValue = (internalId) => context.getFieldValue(internalId, fieldPath);
-  const f = filter;
   const bitsets = [];
   const { capacity } = context;
   let allDocsBitset = null;
@@ -2915,6 +2709,7 @@ function buildFilterContext(state, schema) {
   let cachedAllDocIds = null;
   let cachedAllDocIdsBitset = null;
   return {
+    fieldTypes: flat,
     fieldIndexes,
     getFieldValue: (internalId, fieldPath) => getFieldValueByInternalId(state.docStore, internalId, fieldPath),
     get allDocIds() {
@@ -3236,8 +3031,7 @@ function createValueStore(initialKind) {
     get kind() {
       return kind;
     },
-    set(internalId, value) {
-      const comparable = toComparableSortValue(value);
+    set(internalId, comparable) {
       if (kind === "number") {
         if (comparable === null) {
           setNumber(internalId, Number.NaN);
@@ -3307,6 +3101,12 @@ function createValueStore(initialKind) {
 }
 
 // src/core/partition/sort-columns/index.ts
+function mayHoldList(fieldType) {
+  return fieldType === void 0 || fieldType.endsWith("[]");
+}
+function columnKeyOf(field, fieldType, mode) {
+  return mayHoldList(fieldType) ? `${mode}:${field}` : `value:${field}`;
+}
 function liveInternalIds(docStore) {
   const ids = [];
   for (const internalId of docStore.allInternalIds()) ids.push(internalId);
@@ -3324,21 +3124,22 @@ function createSortColumnSet(docStore) {
     entry.dirty.clear();
     entry.dirtyStream = null;
   }
-  function backfill(field, fieldType) {
+  function backfill(key, field, fieldType, mode) {
     const store = createValueStore(kindForFieldType(fieldType));
     for (const [docId, stored] of docStore.all()) {
       const internalId = docStore.getInternalId(docId);
       if (internalId === void 0) continue;
-      store.set(internalId, readSortField(stored.fields, field));
+      store.set(internalId, toReducedSortValue(readSortField(stored.fields, field), mode));
     }
     const entry = {
       field,
+      mode,
       store,
       order: buildOrder(store, liveInternalIds(docStore), docStore.internalIdCapacity()),
       dirty: /* @__PURE__ */ new Set(),
       dirtyStream: null
     };
-    columns.set(field, entry);
+    columns.set(key, entry);
     return entry;
   }
   function buildDirtyStream(entry) {
@@ -3391,13 +3192,14 @@ function createSortColumnSet(docStore) {
     };
   }
   return {
-    holds(field) {
-      return columns.has(field);
+    holds(field, fieldType, mode) {
+      return columns.has(columnKeyOf(field, fieldType, mode));
     },
-    column(field, fieldType) {
-      let entry = columns.get(field);
+    column(field, fieldType, mode) {
+      const key = columnKeyOf(field, fieldType, mode);
+      let entry = columns.get(key);
       if (entry === void 0) {
-        entry = backfill(field, fieldType);
+        entry = backfill(key, field, fieldType, mode);
       } else if (entry.dirty.size > rebuildThreshold()) {
         rebuild(entry);
       }
@@ -3405,7 +3207,7 @@ function createSortColumnSet(docStore) {
     },
     record(internalId, document) {
       for (const entry of columns.values()) {
-        entry.store.set(internalId, readSortField(document, entry.field));
+        entry.store.set(internalId, toReducedSortValue(readSortField(document, entry.field), entry.mode));
         entry.dirty.add(internalId);
         entry.dirtyStream = null;
       }
@@ -3560,11 +3362,13 @@ function createStream(column, direction, anchorRank) {
   };
 }
 function selectSortedPage(state, request) {
-  const { fields, directions, fieldTypes, limit, anchorKey, anchorId, matches } = request;
+  const { fields, directions, fieldTypes, modes, limit, anchorKey, anchorId, matches } = request;
   if (limit <= 0 || fields.length === 0) return [];
   const set = state.sortColumns;
   if (set === null) return [];
-  const columns = fields.map((field, index) => set.column(field, fieldTypes[index]));
+  const columns = fields.map(
+    (field, index) => set.column(field, fieldTypes[index], modes[index] ?? defaultSortMode(directions[index] ?? "asc"))
+  );
   const resolver = state.docStore.resolver();
   const leading = columns[0];
   const leadingDirection = directions[0];
@@ -3606,17 +3410,18 @@ function sortedPageOf(state, request) {
   ensureColumns(state);
   return selectSortedPage(state, request);
 }
-function sortValuesOf(state, docId, fields, fieldTypes) {
+function sortValuesOf(state, docId, fields, fieldTypes, modes) {
   const set = state.sortColumns;
   const internalId = state.docStore.getInternalId(docId);
   const stored = state.docStore.get(docId);
   const key = new Array(fields.length);
   for (let i = 0; i < fields.length; i++) {
-    if (set !== null && internalId !== void 0 && set.holds(fields[i])) {
-      key[i] = set.column(fields[i], fieldTypes[i]).valueOf(internalId);
+    const mode = modes[i] ?? "min";
+    if (set !== null && internalId !== void 0 && set.holds(fields[i], fieldTypes[i], mode)) {
+      key[i] = set.column(fields[i], fieldTypes[i], mode).valueOf(internalId);
       continue;
     }
-    key[i] = stored === void 0 ? null : toComparableSortValue(readSortField(stored.fields, fields[i]));
+    key[i] = stored === void 0 ? null : toReducedSortValue(readSortField(stored.fields, fields[i]), mode);
   }
   return key;
 }
@@ -5647,8 +5452,8 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     sortedPage(request) {
       return sortedPageOf(state, request);
     },
-    sortValues(docId, fields, fieldTypes) {
-      return sortValuesOf(state, docId, fields, fieldTypes);
+    sortValues(docId, fields, fieldTypes, modes) {
+      return sortValuesOf(state, docId, fields, fieldTypes, modes);
     },
     applyFilters(filters, schema) {
       return applyPartitionFilters(state, filters, schema);
@@ -6040,10 +5845,10 @@ function compositeSortedPage(subs, layout, request) {
   if (merged.length > request.limit) merged.length = request.limit;
   return merged;
 }
-function compositeSortValues(subs, docId, fields, fieldTypes) {
+function compositeSortValues(subs, docId, fields, fieldTypes, modes) {
   for (const sub of subs) {
     if (sub.docStore.has(docId)) {
-      return sortValuesOf(sub, docId, fields, fieldTypes);
+      return sortValuesOf(sub, docId, fields, fieldTypes, modes);
     }
   }
   return fields.map(() => null);
@@ -6268,6 +6073,7 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
       return compositeFilterMatches(subs(), layout(), filters, schema);
     },
     computeFacets(matched, config, schema) {
+      const everyValue = everyValueFacetConfig(config);
       if ("ordinalBitset" in matched) {
         const ordinalLayout = layout();
         return mergeFacets(
@@ -6275,19 +6081,23 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
             (sub, index) => computeFacets(
               sub,
               { ordinalBitset: subBitsetView(matched.ordinalBitset, ordinalLayout, index) },
-              config,
+              everyValue,
               schema
             )
-          )
+          ),
+          config
         );
       }
-      return mergeFacets(subs().map((sub) => computeFacets(sub, matched, config, schema)));
+      return mergeFacets(
+        subs().map((sub) => computeFacets(sub, matched, everyValue, schema)),
+        config
+      );
     },
     sortedPage(request) {
       return compositeSortedPage(subs(), layout(), request);
     },
-    sortValues(docId, fields, fieldTypes) {
-      return compositeSortValues(subs(), docId, fields, fieldTypes);
+    sortValues(docId, fields, fieldTypes, modes) {
+      return compositeSortValues(subs(), docId, fields, fieldTypes, modes);
     },
     suggestTerms(surfacePrefix, stemmedPrefix, limit) {
       return compositeSuggestTerms(subs(), surfacePrefix, stemmedPrefix, limit);
@@ -6572,10 +6382,10 @@ function createPartitionManager(indexName, config, language, router, initialPart
       if (pid === void 0) return void 0;
       return partitions[pid].getRef(docId);
     },
-    sortValues(docId, fields, fieldTypes) {
+    sortValues(docId, fields, fieldTypes, modes) {
       const pid = locateDocument(docId);
       if (pid === void 0) return fields.map(() => null);
-      return partitions[pid].sortValues(docId, fields, fieldTypes);
+      return partitions[pid].sortValues(docId, fields, fieldTypes, modes);
     },
     has(docId) {
       return locateDocument(docId) !== void 0;
@@ -6895,6 +6705,14 @@ async function spawnNodeWorker(entryPoint, resourceLimits) {
     return null;
   }
 }
+async function nodeThreadId() {
+  try {
+    const workerThreads = await import('worker_threads');
+    return workerThreads.threadId;
+  } catch {
+    return 0;
+  }
+}
 async function isNodeMainThread() {
   try {
     const workerThreads = await import('worker_threads');
@@ -6904,6 +6722,21 @@ async function isNodeMainThread() {
   }
 }
 
+// src/workers/entry-point.ts
+var DIST_SEGMENT = "/dist/";
+function resolveWorkerEntry(moduleUrl, sourceDirectory, distEntry) {
+  const distIndex = moduleUrl.lastIndexOf(DIST_SEGMENT);
+  const entry = distIndex !== -1 ? new URL(distEntry, moduleUrl.slice(0, distIndex + DIST_SEGMENT.length)).href : sourceDirectory.test(moduleUrl) ? moduleUrl.replace(sourceDirectory, `${DIST_SEGMENT}${distEntry}`) : null;
+  return entry === moduleUrl ? null : entry;
+}
+function missingWorkerEntry(moduleUrl) {
+  return new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `The engine finds no worker entry beside its own module at "${moduleUrl}", which happens where a bundler folds @delali/narsil into an application bundle. Keep @delali/narsil outside the bundle, or set workers.enabled to false`,
+    { moduleUrl }
+  );
+}
+
 // src/workers/resource-limits.ts
 function workerResourceLimits() {
   return { maxYoungGenerationSizeMb: WORKER_YOUNG_GENERATION_MB };
@@ -6911,14 +6744,10 @@ function workerResourceLimits() {
 
 // src/vector/search-pool/spawn.ts
 function resolveWorkerEntryPoint() {
-  const base = import.meta.url;
-  const distIndex = base.lastIndexOf("/dist/");
-  if (distIndex !== -1) {
-    return new URL("vector/search-worker.mjs", base.slice(0, distIndex + 6)).href;
-  }
-  return base.replace(/\/src\/vector\/search-pool\/[^/]+$/, "/dist/vector/search-worker.mjs");
+  return resolveWorkerEntry(import.meta.url, /\/src\/vector\/search-pool\/[^/]+$/, "vector/search-worker.mjs");
 }
 async function spawnWorker(entryPoint) {
+  if (entryPoint === null) return null;
   const runtime = detectRuntime();
   if (runtime.supportsWorkerThreads) {
     try {
@@ -8580,6 +8409,18 @@ function* filteredDocIds(state, filter) {
     if (docId !== void 0) yield docId;
   }
 }
+function admittedTotal(state, filter) {
+  return filter === void 0 ? liveSize(state) : filter.count;
+}
+function fetchedOutcome(state, results, minSimilarity, filter) {
+  if (minSimilarity === Number.NEGATIVE_INFINITY) {
+    return { results, matched: admittedTotal(state, filter), matchedExact: true };
+  }
+  return { results, matched: results.length, matchedExact: false };
+}
+function scannedOutcome(scan2) {
+  return { results: scan2.results, matched: scan2.matched, matchedExact: true };
+}
 function highScoreFirst(a, b) {
   return b.score - a.score || compareCodePoints(a.docId, b.docId);
 }
@@ -8599,12 +8440,15 @@ function scanThroughTheCore(state, query, k, metric, minSimilarity, scanned) {
   const distances = nativeScoresOf(state.store.handles, query, metric, scanned.ordinals);
   if (distances === null) return null;
   const heap = createBoundedMaxHeap(highScoreFirst, k);
+  let matched = 0;
   for (let i = 0; i < scanned.ordinals.length; i++) {
     if (distances[i] === Number.POSITIVE_INFINITY) continue;
     const score = toScore(distances[i], metric);
-    if (score >= minSimilarity) heap.push({ docId: scanned.docIds[i], score });
+    if (score < minSimilarity) continue;
+    matched++;
+    heap.push({ docId: scanned.docIds[i], score });
   }
-  return heap.toSortedArray().reverse();
+  return { results: heap.toSortedArray().reverse(), matched };
 }
 function bruteForceSearch(state, query, k, metric, minSimilarity, candidates) {
   const scanned = liveCandidates(state, candidates);
@@ -8614,6 +8458,7 @@ function bruteForceSearch(state, query, k, metric, minSimilarity, candidates) {
   const arenaQuery = state.store.prepareQueryArena(query);
   const queryMag = arenaQuery ? arenaQuery.magnitude : magnitude(query);
   const heap = createBoundedMaxHeap(highScoreFirst, k);
+  let matched = 0;
   for (let i = 0; i < scanned.docIds.length; i++) {
     const docId = scanned.docIds[i];
     let score;
@@ -8638,11 +8483,11 @@ function bruteForceSearch(state, query, k, metric, minSimilarity, candidates) {
         }
       }
     }
-    if (score >= minSimilarity) {
-      heap.push({ docId, score });
-    }
+    if (score < minSimilarity) continue;
+    matched++;
+    heap.push({ docId, score });
   }
-  return heap.toSortedArray().reverse();
+  return { results: heap.toSortedArray().reverse(), matched };
 }
 function mergeResults(hnswResults, bufferResults, k) {
   const seen = /* @__PURE__ */ new Set();
@@ -8688,32 +8533,38 @@ function searchWithFilter(state, query, k, options, filter) {
     );
   }
   const currentLiveSize = liveSize(state);
-  if (currentLiveSize === 0) return [];
-  if (k <= 0) return [];
+  const { metric, minSimilarity, efSearch, oversample } = options;
+  if (currentLiveSize === 0) return { results: [], matched: 0, matchedExact: true };
+  if (filter && filter.count === 0) return { results: [], matched: 0, matchedExact: true };
+  if (k <= 0) return fetchedOutcome(state, [], minSimilarity, filter);
   if (state.buffer.size > 0 && !state.building && !state.buildScheduled) {
     scheduleBuild(state);
   }
-  const { metric, minSimilarity, efSearch, oversample } = options;
-  if (filter && filter.count === 0) return [];
   if (!state.hnsw) {
     const candidates = filter ? filteredDocIds(state, filter) : allLiveDocIds(state);
-    return bruteForceSearch(state, query, k, metric, minSimilarity, candidates);
+    return scannedOutcome(bruteForceSearch(state, query, k, metric, minSimilarity, candidates));
   }
   if (filter) {
     const hnswLiveSize = state.hnsw.size;
     const selectivity = hnswLiveSize > 0 ? filter.count / hnswLiveSize : 1;
     if (selectivity < state.filterThreshold) {
-      return bruteForceSearch(state, query, k, metric, minSimilarity, filteredDocIds(state, filter));
+      const scan2 = bruteForceSearch(state, query, k, metric, minSimilarity, filteredDocIds(state, filter));
+      return scannedOutcome(scan2);
     }
   }
   const graphOptions = { filter, efSearch, oversample };
   if (state.buffer.size === 0) {
     const hnswResults2 = state.hnsw.search(query, k, metric, minSimilarity, graphOptions);
-    return hnswResults2.map((r) => ({ docId: r.docId, score: r.score }));
+    return fetchedOutcome(
+      state,
+      hnswResults2.map((r) => ({ docId: r.docId, score: r.score })),
+      minSimilarity,
+      filter
+    );
   }
   const hnswResults = state.hnsw.search(query, k, metric, minSimilarity, graphOptions).map((r) => ({ docId: r.docId, score: r.score }));
-  const bufferResults = bruteForceSearch(state, query, k, metric, minSimilarity, bufferCandidates(state, filter));
-  return mergeResults(hnswResults, bufferResults, k);
+  const buffered = bruteForceSearch(state, query, k, metric, minSimilarity, bufferCandidates(state, filter));
+  return fetchedOutcome(state, mergeResults(hnswResults, buffered.results, k), minSimilarity, filter);
 }
 
 // src/vector/vector-index/index.ts
@@ -8888,7 +8739,7 @@ function createVectorIndex(fieldName, dimension, config, workerCopies = VECTOR_W
       efSearch: options.efSearch,
       oversample: options.oversample
     });
-    if (viaWorkerCopy !== null) return viaWorkerCopy;
+    if (viaWorkerCopy !== null) return fetchedOutcome(state, viaWorkerCopy, options.minSimilarity, filter);
     if (confined && state.revision !== filterRevision) {
       filter = filterForOptions(state, options);
     }
@@ -10897,20 +10748,26 @@ function bruteForceOrdinals(state, docIdOf, query, k, metric, minSimilarity, fil
   }
   const distances = nativeScoresOf(state.store.handles, query, metric, ordinals) ?? distancesInTypeScript(state, query, metric, ordinals);
   const heap = createBoundedMaxHeap(bestFirst, k);
+  let matched = 0;
   for (let i = 0; i < ordinals.length; i++) {
     if (distances[i] === Number.POSITIVE_INFINITY) continue;
     const score = toScore(distances[i], metric);
-    if (score >= minSimilarity) heap.push({ ord: ordinals[i], score, docId: docIds[i] });
+    if (score < minSimilarity) continue;
+    matched++;
+    heap.push({ ord: ordinals[i], score, docId: docIds[i] });
   }
-  return heap.toSortedArray().reverse();
+  return { hits: heap.toSortedArray().reverse(), matched, matchedExact: true };
 }
 function createSharedVectorSearcher(options) {
   const { fieldName, view, holdsDocument } = options;
   function filterForDocIds(allowed) {
     const filter = createOrdinalFilter(view.store.slots);
+    const graph = view.graph;
     for (const docId of allowed) {
       const ordinal = view.ordinalOf(docId);
-      if (ordinal !== void 0) addToOrdinalFilter(filter, ordinal);
+      if (ordinal === void 0) continue;
+      if (graph !== null && isTombstoned(graph, ordinal)) continue;
+      addToOrdinalFilter(filter, ordinal);
     }
     return filter;
   }
@@ -10937,7 +10794,11 @@ function createSharedVectorSearcher(options) {
     if (graph !== null && filter !== void 0 && liveSize2 > 0 && filter.count / liveSize2 < view.handles.filterThreshold) {
       return bruteForceOrdinals(graph, view.docIdOf, query, k, metric, minSimilarity, filter);
     }
-    return view.searchOrdinals(query, k, metric, minSimilarity, { filter, efSearch, oversample });
+    const hits = view.searchOrdinals(query, k, metric, minSimilarity, { filter, efSearch, oversample });
+    if (minSimilarity === Number.NEGATIVE_INFINITY) {
+      return { hits, matched: filter === void 0 ? liveSize2 : filter.count, matchedExact: true };
+    }
+    return { hits, matched: hits.length, matchedExact: false };
   }
   return {
     fieldName,
@@ -10953,15 +10814,22 @@ function createSharedVectorSearcher(options) {
         );
       }
       const filter = filterFor(searchOptions);
-      if (filter !== void 0 && filter.count === 0) return Promise.resolve([]);
-      const hits = hitsFor(query, k, searchOptions, filter);
+      if (filter !== void 0 && filter.count === 0) {
+        return Promise.resolve({ results: [], matched: 0, matchedExact: true });
+      }
+      const scanned = hitsFor(query, k, searchOptions, filter);
       const results = [];
-      for (const hit of hits) {
+      for (const hit of scanned.hits) {
         const docId = view.docIdOf(hit.ord);
         if (docId === void 0 || !holdsDocument(docId)) continue;
         results.push({ docId, score: hit.score });
       }
-      return Promise.resolve(results);
+      const holdsEveryHit = results.length === scanned.hits.length;
+      return Promise.resolve({
+        results,
+        matched: scanned.matched,
+        matchedExact: scanned.matchedExact && holdsEveryHit
+      });
     }
   };
 }
@@ -11297,4 +11165,4 @@ function createDirectExecutor(options) {
   };
 }
 
-export { CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VECTOR_FILE_MAX_VECTORS, buildSegmentPayload, countDead, createCompositePartition, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeVectorFilePayload, decodeVectorGraphPayload, decodeVectorIndexParts, deserializeMetadata, deserializePayloadV1, deserializePayloadV2, documentsOfPayloadV2, encodeSegmentState, freezeSegmentShared, generateId, getLanguage, getNestedValue, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, mergeFrozenSegments, readHeapStatistics, registerLanguage, registerStopWords, registerTokenizer, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, serializeMetadata, spawnNodeWorker, splitWorkerBudget, workerResourceLimits };
+export { CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VECTOR_FILE_MAX_VECTORS, buildSegmentPayload, countDead, createCompositePartition, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeVectorFilePayload, decodeVectorGraphPayload, decodeVectorIndexParts, deserializeMetadata, deserializePayloadV1, deserializePayloadV2, documentsOfPayloadV2, encodeSegmentState, freezeSegmentShared, generateId, getLanguage, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, mergeFrozenSegments, missingWorkerEntry, nodeThreadId, readHeapStatistics, registerLanguage, registerStopWords, registerTokenizer, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, serializeMetadata, spawnNodeWorker, splitWorkerBudget, workerResourceLimits };