@delali/narsil 0.2.4-next.42 → 0.2.4-next.44

package/dist/{chunk-GRWFY2HI.mjs → chunk-XNCJFU2E.mjs}

@@ -3,7 +3,7 @@ import { createScalarQuantizer } from './chunk-OBXS7OZM.mjs';
 import { MAX_M, createVectorStore, createHNSWIndex, createOrdinalFilter, addToOrdinalFilter, removeFromOrdinalFilter, ordinalFilterValues, magnitude, createBoundedMaxHeap, toScore, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, ABSENT_DOCUMENT_RANK } from './chunk-WDL632CN.mjs';
 import { compareCodePoints, compareComparableKeys, toComparableSortValue, readSortField, compareSortValues, compareComparableValues, SORT_VALUE_MAX_CODE_POINTS } from './chunk-BFIH7OV5.mjs';
 import { generateId, createRequestId } from './chunk-WTONLDU3.mjs';
-import { NarsilError, ErrorCodes, createNarsilError } from './chunk-GB2IIJJG.mjs';
+import { NarsilError, ErrorCodes, createNarsilError } from './chunk-P4ELXVJQ.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 // src/schema/validator/shared.ts
@@ -497,6 +497,9 @@ function metadataToWire(meta) {
   if (meta.vectorFields) {
     wire.vector_fields = meta.vectorFields;
   }
+  if (isNonNegativeInteger(meta.documentCount) && Number.isSafeInteger(meta.documentCount)) {
+    wire.document_count = meta.documentCount;
+  }
   if (meta.embedding) {
     wire.embedding = meta.embedding.adapter !== void 0 ? { adapter: meta.embedding.adapter, fields: meta.embedding.fields } : { fields: meta.embedding.fields };
   }
@@ -570,6 +573,9 @@ function wireToMetadata(raw) {
   if (raw.vector_fields) {
     meta.vectorFields = raw.vector_fields;
   }
+  if (isNonNegativeInteger(raw.document_count) && Number.isSafeInteger(raw.document_count)) {
+    meta.documentCount = raw.document_count;
+  }
   if (raw.embedding && typeof raw.embedding === "object" && typeof raw.embedding.fields === "object") {
     meta.embedding = typeof raw.embedding.adapter === "string" ? { adapter: raw.embedding.adapter, fields: raw.embedding.fields } : { fields: raw.embedding.fields };
   }
@@ -628,7 +634,7 @@ function wireToMetadata(raw) {
     if (isPositiveInteger2(promotion.threshold)) {
       restored.threshold = promotion.threshold;
     }
-    if (isPositiveInteger2(promotion.filter_threshold)) {
+    if (isSelectivityRatio(promotion.filter_threshold)) {
       restored.filterThreshold = promotion.filter_threshold;
     }
     if (Object.keys(hnswConfig).length > 0) {
@@ -655,6 +661,9 @@ function isNonNegativeInteger(value) {
 function isPositiveInteger2(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 1;
 }
+function isSelectivityRatio(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
 function isWatermarkFraction(value) {
   return typeof value === "number" && value > 0 && value <= 1;
 }
@@ -961,6 +970,46 @@ function documentWithOwnBuffers(document) {
   if (!sharesABiggerBuffer(document)) return document;
   return withOwnBuffers(document);
 }
+var STRING_HEADER_BYTES = 16;
+var TWO_BYTE_SAMPLE_LIMIT = 16;
+var NUMBER_BYTES = 16;
+var PRIMITIVE_SLOT_BYTES = 4;
+var ARRAY_HEADER_BYTES = 32;
+var ARRAY_SLOT_BYTES = 8;
+var OBJECT_HEADER_BYTES = 40;
+var PROPERTY_SLOT_BYTES = 8;
+var TYPED_ARRAY_HEADER_BYTES = 96;
+function stringBytes(value) {
+  const sampled = Math.min(value.length, TWO_BYTE_SAMPLE_LIMIT);
+  for (let i = 0; i < sampled; i += 1) {
+    if (value.charCodeAt(i) > 255) {
+      return STRING_HEADER_BYTES + value.length * 2;
+    }
+  }
+  return STRING_HEADER_BYTES + value.length;
+}
+function documentValueBytes(value) {
+  if (typeof value === "string") return stringBytes(value);
+  if (typeof value === "number") return NUMBER_BYTES;
+  if (value === null || value === void 0 || typeof value === "boolean") return PRIMITIVE_SLOT_BYTES;
+  if (ArrayBuffer.isView(value)) return TYPED_ARRAY_HEADER_BYTES + value.byteLength;
+  if (Array.isArray(value)) {
+    let bytes = ARRAY_HEADER_BYTES + value.length * ARRAY_SLOT_BYTES;
+    for (let i = 0; i < value.length; i += 1) {
+      bytes += documentValueBytes(value[i]);
+    }
+    return bytes;
+  }
+  if (typeof value === "object") {
+    const source = value;
+    let bytes = OBJECT_HEADER_BYTES;
+    for (const key of Object.keys(source)) {
+      bytes += PROPERTY_SLOT_BYTES + documentValueBytes(source[key]);
+    }
+    return bytes;
+  }
+  return PRIMITIVE_SLOT_BYTES;
+}
 function createDocumentStore() {
   const docs = /* @__PURE__ */ new Map();
   const forwardMap = /* @__PURE__ */ new Map();
@@ -968,6 +1017,19 @@ function createDocumentStore() {
   const lengthColumns = /* @__PURE__ */ new Map();
   let nextInternalId = 0;
   let sortedIds = null;
+  let storedContentBytes = 0;
+  function replaceStored(docId, document, fieldLengths) {
+    const existing = docs.get(docId);
+    if (existing !== void 0) {
+      storedContentBytes -= documentValueBytes(existing.fields);
+    } else {
+      sortedIds = null;
+    }
+    writeFieldLengths(assignInternalId(docId), fieldLengths);
+    const fields = documentWithOwnBuffers(document);
+    storedContentBytes += documentValueBytes(fields);
+    docs.set(docId, { fields, fieldLengths });
+  }
   function writeFieldLengths(internalId, fieldLengths) {
     for (const fieldName of Object.keys(fieldLengths)) {
       let column = lengthColumns.get(fieldName);
@@ -1004,21 +1066,21 @@ function createDocumentStore() {
   };
   return {
     store(docId, document, fieldLengths) {
-      if (!docs.has(docId)) sortedIds = null;
-      writeFieldLengths(assignInternalId(docId), fieldLengths);
-      docs.set(docId, { fields: documentWithOwnBuffers(document), fieldLengths });
+      replaceStored(docId, document, fieldLengths);
     },
     storeRef(docId, document, fieldLengths) {
-      if (!docs.has(docId)) sortedIds = null;
-      writeFieldLengths(assignInternalId(docId), fieldLengths);
-      docs.set(docId, { fields: documentWithOwnBuffers(document), fieldLengths });
+      replaceStored(docId, document, fieldLengths);
     },
     get(docId) {
       return docs.get(docId);
     },
     remove(docId) {
+      const existing = docs.get(docId);
       const removed = docs.delete(docId);
       if (removed) {
+        if (existing !== void 0) {
+          storedContentBytes -= documentValueBytes(existing.fields);
+        }
         sortedIds = null;
         const internalId = forwardMap.get(docId);
         if (internalId !== void 0) {
@@ -1055,6 +1117,7 @@ function createDocumentStore() {
       docs.clear();
       lengthColumns.clear();
       clearMappings();
+      storedContentBytes = 0;
     },
     serialize() {
       const result = {};
@@ -1067,10 +1130,12 @@ function createDocumentStore() {
       docs.clear();
       lengthColumns.clear();
       clearMappings();
+      storedContentBytes = 0;
       for (const docId of Object.keys(data)) {
         const stored = data[docId];
         writeFieldLengths(assignInternalId(docId), stored.fieldLengths);
         const fields = documentWithOwnBuffers(stored.fields);
+        storedContentBytes += documentValueBytes(fields);
         docs.set(docId, fields === stored.fields ? stored : { fields, fieldLengths: stored.fieldLengths });
       }
     },
@@ -1094,6 +1159,9 @@ function createDocumentStore() {
     internalIdCapacity() {
       return nextInternalId;
     },
+    contentBytes() {
+      return storedContentBytes;
+    },
     resolver() {
       return idResolver;
     }
@@ -4102,7 +4170,7 @@ var BYTES_PER_NUMBER_SLOT = 8;
 var BYTES_PER_BOOLEAN_SLOT = 1;
 var BYTES_PER_MIXED_SLOT = 8;
 var BYTES_PER_STRING_CODE_UNIT = 2;
-var STRING_HEADER_BYTES = 24;
+var STRING_HEADER_BYTES2 = 24;
 function grow(length, wanted) {
   let next = length === 0 ? 64 : length;
   while (next <= wanted) next *= 2;
@@ -4224,7 +4292,7 @@ function createValueStore(initialKind) {
       for (const value of mixed) {
         if (typeof value !== "string") continue;
         if (value.length < SORT_VALUE_MAX_CODE_POINTS) continue;
-        bytes += STRING_HEADER_BYTES + value.length * BYTES_PER_STRING_CODE_UNIT;
+        bytes += STRING_HEADER_BYTES2 + value.length * BYTES_PER_STRING_CODE_UNIT;
       }
       return bytes;
     }
@@ -4563,15 +4631,17 @@ function sortColumnBytes(state) {
 }
 
 // src/core/partition/memory.ts
-var AVG_DOC_OVERHEAD = 350;
-var POSTING_ENTRY_SIZE = 24;
-var PER_TERM_OVERHEAD = 180;
-var SURFACE_ENTRY_OVERHEAD = 140;
-var FIELD_ENTRY_OVERHEAD = 42;
+var DOC_ENTRY_OVERHEAD_BYTES = 260;
+var LENGTH_COLUMN_SLOT_BYTES = 6;
+var POSTING_ENTRY_BYTES = 40;
+var POSITIONS_ARRAY_OVERHEAD_BYTES = 88;
+var POSITION_BYTES = 8;
+var PER_TERM_OVERHEAD_BYTES = 180;
+var SURFACE_ENTRY_OVERHEAD_BYTES = 140;
+var FIELD_ENTRY_OVERHEAD_BYTES = 42;
 function estimatePartitionBytes(state) {
   const docCount = state.docStore.count();
   if (docCount === 0) return 0;
-  let bytes = docCount * AVG_DOC_OVERHEAD;
   const docFreqs = state.stats.docFrequencies;
   let totalPostings = 0;
   let termCount = 0;
@@ -4579,13 +4649,27 @@ function estimatePartitionBytes(state) {
     totalPostings += docFreqs[term];
     termCount++;
   }
-  bytes += totalPostings * POSTING_ENTRY_SIZE;
-  bytes += termCount * PER_TERM_OVERHEAD;
-  bytes += state.surfaceRegistry.size() * SURFACE_ENTRY_OVERHEAD;
-  bytes += docCount * state.numericIndexes.size * FIELD_ENTRY_OVERHEAD;
-  bytes += docCount * state.booleanIndexes.size * FIELD_ENTRY_OVERHEAD;
-  bytes += docCount * state.enumIndexes.size * FIELD_ENTRY_OVERHEAD;
-  bytes += docCount * state.geoIndexes.size * FIELD_ENTRY_OVERHEAD;
+  const fieldLengthTotals = state.stats.totalFieldLengths;
+  let totalTokenOccurrences = 0;
+  let textFieldCount = 0;
+  for (const field in fieldLengthTotals) {
+    totalTokenOccurrences += fieldLengthTotals[field];
+    textFieldCount++;
+  }
+  let bytes = state.docStore.contentBytes();
+  bytes += docCount * DOC_ENTRY_OVERHEAD_BYTES;
+  bytes += textFieldCount * state.docStore.internalIdCapacity() * LENGTH_COLUMN_SLOT_BYTES;
+  bytes += totalPostings * POSTING_ENTRY_BYTES;
+  if (state.trackPositions) {
+    bytes += totalPostings * POSITIONS_ARRAY_OVERHEAD_BYTES;
+    bytes += totalTokenOccurrences * POSITION_BYTES;
+  }
+  bytes += termCount * PER_TERM_OVERHEAD_BYTES;
+  bytes += state.surfaceRegistry.size() * SURFACE_ENTRY_OVERHEAD_BYTES;
+  bytes += docCount * state.numericIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
+  bytes += docCount * state.booleanIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
+  bytes += docCount * state.enumIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
+  bytes += docCount * state.geoIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
   return bytes + sortColumnBytes(state);
 }
 
@@ -6434,6 +6518,9 @@ function createFrozenDocTable(idTable, lengthColumns, documents, tombstones) {
     internalIdCapacity() {
       return capacity;
     },
+    contentBytes() {
+      return documents.byteLength;
+    },
     resolver() {
       return resolver;
     }
@@ -6461,21 +6548,32 @@ function wrapEncodedDocumentTable(data) {
   const { blob, offsets } = data;
   const count = offsets.length - 1;
   const decoded = new Array(count);
+  const encodedBytes = blob.byteLength + offsets.byteLength;
+  let decodedBytes = 0;
   return {
     count,
+    get byteLength() {
+      return encodedBytes + decodedBytes;
+    },
     docAt(ordinal) {
       let document = decoded[ordinal];
       if (document === void 0) {
         document = decode(blob.slice(offsets[ordinal], offsets[ordinal + 1]));
         decoded[ordinal] = document;
+        decodedBytes += documentValueBytes(document);
       }
       return document;
     }
   };
 }
 function wrapDocumentArray(documents) {
+  let residentBytes = 0;
+  for (const document of documents) {
+    residentBytes += documentValueBytes(document);
+  }
   return {
     count: documents.length,
+    byteLength: residentBytes,
     docAt(ordinal) {
       return documents[ordinal];
     }
@@ -8205,7 +8303,7 @@ function applySorting(hits, sort, sortKeyOf) {
 }
 
 // src/search/cursor.ts
-var CURSOR_VERSION = 2;
+var CURSOR_VERSION = 3;
 var MAX_CURSOR_LENGTH = 40960;
 var MAX_SORT_FIELDS = 8;
 var MAX_SORT_FIELD_NAME_LENGTH = 255;
@@ -8260,6 +8358,7 @@ function encodePageCursor(cursor) {
   } else if (cursor.score !== null) {
     payload.s = cursor.score;
   }
+  payload.q = cursor.binding;
   return encodeCursorText(JSON.stringify(payload));
 }
 function decodeSortKey(value, cursor) {
@@ -8304,8 +8403,11 @@ function decodePageCursor(cursor) {
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw invalidCursor(cursor, "expected an object");
   }
-  const { v, a, s, k, o } = parsed;
+  const { v, a, s, k, o, q } = parsed;
   if (v !== CURSOR_VERSION) throw invalidCursor(cursor, `unsupported cursor version ${String(v)}`);
+  if (typeof q !== "string" || !/^[0-9a-f]{8}$/.test(q)) {
+    throw invalidCursor(cursor, '"q" must be 8 lowercase hex digits');
+  }
   if (typeof a !== "string" || a.length === 0) throw invalidCursor(cursor, '"a" must be a non-empty string');
   if (exceedsCodePoints(a, MAX_ANCHOR_CODE_POINTS)) {
     throw invalidCursor(cursor, '"a" is too long to be a document id');
@@ -8323,10 +8425,14 @@ function decodePageCursor(cursor) {
     anchor: a,
     score: typeof s === "number" ? s : null,
     sortKey,
-    sortSignature: typeof o === "string" ? o : null
+    sortSignature: typeof o === "string" ? o : null,
+    binding: q
   };
 }
-function requireMatchingCursor(cursor, encoded, signature, scoreAnchored) {
+function requireMatchingCursor(cursor, encoded, signature, scoreAnchored, binding) {
+  if (cursor.binding !== binding) {
+    throw invalidCursor(encoded, "the cursor belongs to a different query");
+  }
   if (signature !== null) {
     if (cursor.sortSignature !== signature) {
       throw invalidCursor(encoded, "the cursor belongs to a different sort order");
@@ -8360,6 +8466,12 @@ function requireWithinResultWindow(limit, offset) {
     { limit, offset, window: RESULT_WINDOW }
   );
 }
+function lastOrganicResult(sliced, pinnedIds) {
+  for (let i = sliced.length - 1; i >= 0; i--) {
+    if (pinnedIds === void 0 || !pinnedIds.has(sliced[i].id)) return sliced[i];
+  }
+  return void 0;
+}
 function ordersAfterAnchor(result, anchor, sort) {
   if (sort !== void 0 && anchor.sortKey !== null) {
     const comparison = compareSortValues(sort.sortKeyOf(result.id), anchor.sortKey, sort.directions) || compareCodePoints(result.id, anchor.anchor);
@@ -8370,10 +8482,10 @@ function ordersAfterAnchor(result, anchor, sort) {
   if (result.score < anchor.score) return true;
   return result.score === anchor.score && compareCodePoints(result.id, anchor.anchor) > 0;
 }
-function applyPagination(results, limit, offset, cursor, sort) {
+function applyPagination(results, limit, offset, binding, cursor, sort, pinnedIds) {
   const decoded = cursor ? decodePageCursor(cursor) : null;
   if (decoded !== null && cursor !== void 0) {
-    requireMatchingCursor(decoded, cursor, sort?.signature ?? null, true);
+    requireMatchingCursor(decoded, cursor, sort?.signature ?? null, true, binding);
   }
   if (limit <= 0) {
     return { paginated: [] };
@@ -8392,18 +8504,20 @@ function applyPagination(results, limit, offset, cursor, sort) {
   const sliced = results.slice(afterOffset, afterOffset + limit);
   let nextCursor;
   const hasMore = afterOffset + limit < results.length;
-  if (hasMore && sliced.length > 0) {
-    const lastResult = sliced[sliced.length - 1];
+  const lastResult = lastOrganicResult(sliced, pinnedIds);
+  if (hasMore && lastResult !== void 0) {
     nextCursor = sort !== void 0 ? encodePageCursor({
       anchor: lastResult.id,
       score: null,
       sortKey: sort.sortKeyOf(lastResult.id).map(toComparableSortValue),
-      sortSignature: sort.signature
+      sortSignature: sort.signature,
+      binding
     }) : encodePageCursor({
       anchor: lastResult.id,
       score: lastResult.score ?? null,
       sortKey: null,
-      sortSignature: null
+      sortSignature: null,
+      binding
     });
   }
   return { paginated: sliced, nextCursor };
@@ -8603,9 +8717,24 @@ function queryTermSatisfied(queryToken, indexTokens, tolerance, exact) {
   return false;
 }
 
+// src/partitioning/partition-selection.ts
+function partitionsIn(manager, partitionIds) {
+  if (partitionIds === void 0) {
+    return manager.getAllPartitions();
+  }
+  const partitions = [];
+  for (const partitionId of partitionIds) {
+    const partition = manager.partitionAt(partitionId);
+    if (partition !== void 0) {
+      partitions.push(partition);
+    }
+  }
+  return partitions;
+}
+
 // src/partitioning/fan-out.ts
 async function fanOutQuery(manager, params, language, schema, config, searchOptions) {
-  const partitions = config.partitionIds ? config.partitionIds.map((id) => manager.partitionAt(id)).filter((p) => p !== void 0) : manager.getAllPartitions();
+  const partitions = partitionsIn(manager, config.partitionIds);
   if (partitions.length === 0) {
     return { scored: [], totalMatched: 0 };
   }
@@ -9093,12 +9222,24 @@ function createPartitionManager(indexName, config, language, router, initialPart
   return manager;
 }
 
+// src/partitioning/match-count.ts
+function countsWithoutScores(params) {
+  return params.minScore === void 0 && (params.termMatch === void 0 || params.termMatch === "any");
+}
+function fanOutMatchCount(manager, params, language, schema, options) {
+  let count = 0;
+  for (const partition of partitionsIn(manager, options?.partitionIds)) {
+    const matches = fulltextMatches(partition, params, language, schema, options?.searchOptions);
+    if (matches !== null) count += matches.count;
+  }
+  return count;
+}
+
 // src/core/hash.ts
 var FNV_OFFSET_BASIS = 2166136261;
 var FNV_PRIME = 16777619;
 var encoder3 = new TextEncoder();
-function fnv1a(input) {
-  const bytes = encoder3.encode(input);
+function fnv1aBytes(bytes) {
   let hash = FNV_OFFSET_BASIS;
   for (let i = 0; i < bytes.length; i++) {
     hash ^= bytes[i];
@@ -9106,6 +9247,9 @@ function fnv1a(input) {
   }
   return hash >>> 0;
 }
+function fnv1a(input) {
+  return fnv1aBytes(encoder3.encode(input));
+}
 
 // src/partitioning/router.ts
 function createPartitionRouter() {
@@ -9424,20 +9568,43 @@ function resolveWorkerCount(requested) {
 }
 function createWorkerPool(config) {
   const workerCount = resolveWorkerCount(config.count);
-  const workers = [];
+  const workers = /* @__PURE__ */ new Map();
+  const deadSlots = /* @__PURE__ */ new Set();
   const indexAssignment = /* @__PURE__ */ new Map();
   let isShutdown = false;
+  function handleWorkerDeath(slotIndex, error) {
+    if (isShutdown || deadSlots.has(slotIndex)) {
+      return;
+    }
+    deadSlots.add(slotIndex);
+    const slot = workers.get(slotIndex);
+    const indexNames = slot ? [...slot.indexes].sort() : [];
+    workers.delete(slotIndex);
+    config.onWorkerCrash?.(slotIndex, indexNames, error);
+  }
   function ensureWorker(slotIndex) {
-    if (!workers[slotIndex]) {
-      workers[slotIndex] = {
-        executor: config.workerFactory(slotIndex),
+    if (deadSlots.has(slotIndex)) {
+      return void 0;
+    }
+    let slot = workers.get(slotIndex);
+    if (!slot) {
+      slot = {
+        executor: config.workerFactory(slotIndex, (error) => handleWorkerDeath(slotIndex, error)),
         indexes: /* @__PURE__ */ new Set()
       };
+      workers.set(slotIndex, slot);
     }
-    return workers[slotIndex];
+    return slot;
   }
   function assignSlot(indexName) {
-    return fnv1a(indexName) % workerCount;
+    const preferred = fnv1a(indexName) % workerCount;
+    for (let probe = 0; probe < workerCount; probe++) {
+      const candidate = (preferred + probe) % workerCount;
+      if (!deadSlots.has(candidate)) {
+        return candidate;
+      }
+    }
+    throw new NarsilError(ErrorCodes.WORKER_CRASHED, `Every worker in the pool has crashed`);
   }
   function addIndex(indexName) {
     if (isShutdown) {
@@ -9448,18 +9615,14 @@ function createWorkerPool(config) {
     }
     const slotIndex = assignSlot(indexName);
     const slot = ensureWorker(slotIndex);
+    if (!slot) {
+      throw new NarsilError(ErrorCodes.WORKER_CRASHED, `Worker ${slotIndex} for index "${indexName}" has crashed`);
+    }
     slot.indexes.add(indexName);
     indexAssignment.set(indexName, slotIndex);
   }
   function removeIndex(indexName) {
-    const slotIndex = indexAssignment.get(indexName);
-    if (slotIndex === void 0) {
-      return;
-    }
-    const slot = workers[slotIndex];
-    if (slot) {
-      slot.indexes.delete(indexName);
-    }
+    for (const slot of workers.values()) slot.indexes.delete(indexName);
     indexAssignment.delete(indexName);
   }
   function getExecutor(indexName) {
@@ -9470,15 +9633,22 @@ function createWorkerPool(config) {
     if (slotIndex === void 0) {
       throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Index "${indexName}" is not registered in the worker pool`);
     }
-    return workers[slotIndex].executor;
+    const slot = workers.get(slotIndex);
+    if (slot) {
+      return slot.executor;
+    }
+    for (const survivor of workers.values()) {
+      if (survivor.indexes.has(indexName)) {
+        return survivor.executor;
+      }
+    }
+    throw new NarsilError(ErrorCodes.WORKER_CRASHED, `Every worker holding index "${indexName}" has crashed`);
   }
   async function getMemoryStats() {
     const indices = [];
     const pending = [];
-    for (let i = 0; i < workers.length; i++) {
-      const slot = workers[i];
-      if (!slot) continue;
-      indices.push(i);
+    for (const [slotIndex, slot] of workers) {
+      indices.push(slotIndex);
       pending.push(
         slot.executor.execute({ type: "memoryReport", requestId: createRequestId() }).catch(() => null)
       );
@@ -9501,7 +9671,7 @@ function createWorkerPool(config) {
       return;
     }
     isShutdown = true;
-    const shutdownPromises = workers.filter(Boolean).map((slot) => {
+    const shutdownPromises = [...workers.values()].map((slot) => {
       const timeoutPromise = new Promise((resolve) => {
         setTimeout(resolve, 5e3);
       });
@@ -9511,17 +9681,16 @@ function createWorkerPool(config) {
     indexAssignment.clear();
   }
   function getAllExecutors() {
-    return workers.filter(Boolean).map((slot) => slot.executor);
+    return [...workers.values()].map((slot) => slot.executor);
   }
   function addIndexToAll(indexName) {
     if (isShutdown) {
       throw new NarsilError(ErrorCodes.WORKER_CRASHED, "Worker pool has been shut down");
     }
     for (let i = 0; i < workerCount; i++) {
-      const slot = ensureWorker(i);
-      slot.indexes.add(indexName);
+      ensureWorker(i)?.indexes.add(indexName);
     }
-    indexAssignment.set(indexName, 0);
+    indexAssignment.set(indexName, assignSlot(indexName));
   }
   return {
     getExecutor,
@@ -10651,6 +10820,9 @@ function createDirectExecutor() {
   }
   function dropIndex(indexName) {
     const entry = requireIndex(indexName);
+    for (const vectorIndex of entry.vectorIndexes.values()) {
+      vectorIndex.dispose();
+    }
     for (const partition of entry.manager.getAllPartitions()) {
       partition.clear();
     }
@@ -10774,6 +10946,12 @@ function createDirectExecutor() {
       }
       case "preflight": {
         const entry = requireIndex(action.indexName);
+        if (countsWithoutScores(action.params)) {
+          const count = fanOutMatchCount(entry.manager, action.params, entry.language, entry.config.schema, {
+            searchOptions: entry.searchOptions
+          });
+          return { count };
+        }
         const result = await fanOutQuery(
           entry.manager,
           action.params,
@@ -10861,4 +11039,4 @@ function createDirectExecutor() {
   };
 }
 
-export { DEFAULT_PAGE_SIZE, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, MAX_CURSOR_LENGTH, MAX_NESTING_DEPTH, applyPagination, applyProjection, applySorting, buildCompactedSegmentPayload, clampRowCount, clearNormalizationCache, collectQueryTermStats, configureNormalizationCache, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, createVectorIndex, createWorkerPool, decodePageCursor, deserializeMetadata, deserializePayloadV1, deserializePayloadV2, detectRuntime, encodePageCursor, extractVectorFieldsFromSchema, fanOutQuery, flattenSchema, fnv1a, freezeSegmentShared, fulltextMatches, getLanguage, getNestedValue, getNormalizationCacheSize, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, isTextFieldType, kWayMerge, mergeFacets, mergePartitionStats, normalizeSort, pruneStatsToQueryTerms, readSortValues, registerLanguage, registerStopWords, registerTokenizer, requireMatchingCursor, requireSortableFields, requireWithinResultWindow, resetNormalizationCache, resolveIndexAnalysis, resolveProjection, serializeMetadata, sortSignatureOf, spawnNodeWorker, tokenize, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion };
+export { DEFAULT_PAGE_SIZE, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, MAX_CURSOR_LENGTH, MAX_NESTING_DEPTH, RESULT_WINDOW, applyPagination, applyProjection, applySorting, buildCompactedSegmentPayload, clampRowCount, clearNormalizationCache, collectQueryTermStats, configureNormalizationCache, countsWithoutScores, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, createVectorIndex, createWorkerPool, decodePageCursor, deserializeMetadata, deserializePayloadV1, deserializePayloadV2, detectRuntime, encodePageCursor, extractVectorFieldsFromSchema, fanOutMatchCount, fanOutQuery, flattenSchema, fnv1a, fnv1aBytes, freezeSegmentShared, fulltextMatches, getLanguage, getNestedValue, getNormalizationCacheSize, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, isTextFieldType, kWayMerge, mergeFacets, mergePartitionStats, normalizeSort, partitionsIn, pruneStatsToQueryTerms, readSortValues, registerLanguage, registerStopWords, registerTokenizer, requireMatchingCursor, requireSortableFields, requireWithinResultWindow, resetNormalizationCache, resolveIndexAnalysis, resolveProjection, serializeMetadata, sortSignatureOf, spawnNodeWorker, tokenize, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion };

package/dist/{chunk-WU2UZEVD.mjs → chunk-XWICBGYT.mjs}

@@ -1,4 +1,4 @@
-import { NarsilError, ErrorCodes } from './chunk-GB2IIJJG.mjs';
+import { NarsilError, ErrorCodes } from './chunk-P4ELXVJQ.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 var INDEX_CONFIG_PREFIX = "_narsil/index/";

package/dist/{client-BobVnoIK.d.ts → client-C5BkUqB8.d.ts}

@@ -1,6 +1,6 @@
-import { V as VectorMaintenanceResult, M as MemoryStats, B as BatchResult, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, P as PartitionStatsResult, Q as QueryParams, e as QueryResult, h as PreflightResult, i as SuggestParams, j as SuggestResult } from './search-DHuXwJYk.js';
-import { P as PartitionConfig, A as AnyDocument, a as InsertOptions } from './schema-ZRbk8BgH.js';
-import { e as TaskRecord, b as ImportResult, H as HttpIndexConfig, c as TaskListQuery, T as TaskListPage } from './tasks-CnMLpfk-.js';
+import { V as VectorMaintenanceResult, M as MemoryStats, B as BatchResult, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, P as PartitionStatsResult, Q as QueryParams, e as QueryResult, h as PreflightResult, i as SuggestParams, j as SuggestResult } from './search-DDHjfXhJ.js';
+import { P as PartitionConfig, A as AnyDocument, b as InsertOptions } from './schema-B7juWg8Q.js';
+import { e as TaskRecord, b as ImportResult, H as HttpIndexConfig, c as TaskListQuery, T as TaskListPage } from './tasks-Bn4R1NPN.js';
 
 /**
  * This is the `fetch` implementation the client sends every request through.
@@ -521,6 +521,29 @@ interface IndexOperations {
      * this request.
      */
     clear(indexName: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Loads a closed index into server memory and marks it active, so the first
+     * query pays no recovery wait. Opening an index that failed to reopen clears
+     * its parked error and retries the recovery.
+     *
+     * @param indexName - This names the index to open.
+     * @param options - This sets the signal, the deadline, and the headers for
+     * this request.
+     * @throws A `NarsilError` with `INDEX_NOT_FOUND` for an unknown name, and
+     * with the recovery error when the index cannot load.
+     */
+    open(indexName: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Checkpoints an index and releases its server memory. The data stays on
+     * disk, and the next operation that names the index reopens it.
+     *
+     * @param indexName - This names the index to close.
+     * @param options - This sets the signal, the deadline, and the headers for
+     * this request.
+     * @throws A `NarsilError` with `INDEX_NOT_FOUND` for an unknown name, and
+     * with `CONFIG_INVALID` when the server runs without durability.
+     */
+    close(indexName: string, options?: RequestOptions): Promise<void>;
 }
 
 /**

package/dist/client.d.ts

@@ -1,10 +1,10 @@
-export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes } from './search-DHuXwJYk.js';
-export { A as ASYNC_IMPORT_CAPABILITY, E as ErrorEnvelope, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './options-EXYFcem-.js';
-export { C as CapabilitiesResponse, a as CreateIndexEmbedding, H as HttpIndexConfig, I as ImportError, b as ImportResult, T as TaskListPage, c as TaskListQuery, d as TaskProgress, e as TaskRecord, f as TaskStatus, g as TaskType } from './tasks-CnMLpfk-.js';
-export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-BobVnoIK.js';
-import './schema-ZRbk8BgH.js';
+export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes } from './search-DDHjfXhJ.js';
+export { A as ASYNC_IMPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './options-BC68VPoE.js';
+export { C as CapabilitiesResponse, a as CreateIndexEmbedding, H as HttpIndexConfig, I as ImportError, b as ImportResult, T as TaskListPage, c as TaskListQuery, d as TaskProgress, e as TaskRecord, f as TaskStatus, g as TaskType } from './tasks-Bn4R1NPN.js';
+export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-C5BkUqB8.js';
+import './schema-B7juWg8Q.js';
 import './adapters-79OIa4xm.js';
-import './config-fLC4lbmg.js';
-import './config-Byyl1QqH.js';
-import './types-B5Tsaalz.js';
+import './config-B-ZI-ft5.js';
+import './config-BZRExglL.js';
+import './types-DsSSjY4d.js';
 import './types-D5OwhtsQ.js';