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

package/dist/index.browser.mjs

@@ -3,7 +3,6 @@ import { encode, decode } from '@msgpack/msgpack';
 // src/errors.ts
 var ErrorCodes = {
   SCHEMA_INVALID_TYPE: "SCHEMA_INVALID_TYPE",
-  SCHEMA_MISSING_FIELD: "SCHEMA_MISSING_FIELD",
   SCHEMA_DEPTH_EXCEEDED: "SCHEMA_DEPTH_EXCEEDED",
   SCHEMA_INVALID_VECTOR_DIMENSION: "SCHEMA_INVALID_VECTOR_DIMENSION",
   SCHEMA_INVALID_GEOPOINT: "SCHEMA_INVALID_GEOPOINT",
@@ -13,6 +12,7 @@ var ErrorCodes = {
   INDEX_NOT_FOUND: "INDEX_NOT_FOUND",
   INDEX_ALREADY_EXISTS: "INDEX_ALREADY_EXISTS",
   INDEX_ORPHANED: "INDEX_ORPHANED",
+  INDEX_REOPEN_CAPACITY_EXHAUSTED: "INDEX_REOPEN_CAPACITY_EXHAUSTED",
   PARTITION_CORRUPTED: "PARTITION_CORRUPTED",
   PARTITION_REBALANCING_BACKPRESSURE: "PARTITION_REBALANCING_BACKPRESSURE",
   WORKER_CRASHED: "WORKER_CRASHED",
@@ -25,7 +25,6 @@ var ErrorCodes = {
   PERSISTENCE_WAL_CORRUPT: "PERSISTENCE_WAL_CORRUPT",
   PERSISTENCE_FSYNC_FAILED: "PERSISTENCE_FSYNC_FAILED",
   SEARCH_INVALID_FIELD: "SEARCH_INVALID_FIELD",
-  SEARCH_INVALID_VECTOR_SIZE: "SEARCH_INVALID_VECTOR_SIZE",
   VECTOR_DIMENSION_MISMATCH: "VECTOR_DIMENSION_MISMATCH",
   SEARCH_INVALID_FILTER: "SEARCH_INVALID_FILTER",
   SEARCH_INVALID_MODE: "SEARCH_INVALID_MODE",
@@ -49,8 +48,6 @@ var ErrorCodes = {
   ALLOCATION_NO_DATA_NODES: "ALLOCATION_NO_DATA_NODES",
   ALLOCATION_INVALID_CONFIG: "ALLOCATION_INVALID_CONFIG",
   ALLOCATION_FAILED: "ALLOCATION_FAILED",
-  CONTROLLER_LEASE_LOST: "CONTROLLER_LEASE_LOST",
-  CONTROLLER_NOT_ACTIVE: "CONTROLLER_NOT_ACTIVE",
   CONTROLLER_METADATA_INVALID: "CONTROLLER_METADATA_INVALID",
   NODE_BOOTSTRAP_FAILED: "NODE_BOOTSTRAP_FAILED",
   NODE_ALREADY_JOINED: "NODE_ALREADY_JOINED",
@@ -106,6 +103,7 @@ var ServerErrorCodes = {
   TASK_NOT_FOUND: "TASK_NOT_FOUND",
   TASK_NOT_CANCELLABLE: "TASK_NOT_CANCELLABLE",
   TASK_OWNED_BY_ANOTHER_INSTANCE: "TASK_OWNED_BY_ANOTHER_INSTANCE",
+  TASK_INTERRUPTED: "TASK_INTERRUPTED",
   TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS",
   HOOK_ERROR: "HOOK_ERROR",
   INTERNAL_ERROR: "INTERNAL_ERROR"
@@ -2491,6 +2489,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 };
   }
@@ -2564,6 +2565,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 };
   }
@@ -2622,7 +2626,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) {
@@ -2649,6 +2653,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;
 }
@@ -3139,6 +3146,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();
@@ -3146,6 +3193,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);
@@ -3182,21 +3242,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) {
@@ -3233,6 +3293,7 @@ function createDocumentStore() {
       docs.clear();
       lengthColumns.clear();
       clearMappings();
+      storedContentBytes = 0;
     },
     serialize() {
       const result = {};
@@ -3245,10 +3306,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 });
       }
     },
@@ -3272,6 +3335,9 @@ function createDocumentStore() {
     internalIdCapacity() {
       return nextInternalId;
     },
+    contentBytes() {
+      return storedContentBytes;
+    },
     resolver() {
       return idResolver;
     }
@@ -5803,7 +5869,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;
@@ -5925,7 +5991,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;
     }
@@ -6264,15 +6330,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;
@@ -6280,13 +6348,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);
 }
 
@@ -8079,7 +8161,7 @@ function createRebalancer() {
         skipClone: true,
         stopWordOverride: manager.analysis.stopWords,
         customTokenizer: manager.analysis.customTokenizer,
-        collectSurfaces: manager.config.surfaceForms === true
+        collectSurfaces: manager.config.surfaceForms !== false
       };
       for (const partition of currentPartitions) {
         const docIds = [...partition.docIds()];
@@ -8140,8 +8222,7 @@ function createRebalancer() {
 var FNV_OFFSET_BASIS = 2166136261;
 var FNV_PRIME = 16777619;
 var encoder = new TextEncoder();
-function fnv1a(input) {
-  const bytes = encoder.encode(input);
+function fnv1aBytes(bytes) {
   let hash = FNV_OFFSET_BASIS;
   for (let i = 0; i < bytes.length; i++) {
     hash ^= bytes[i];
@@ -8149,6 +8230,9 @@ function fnv1a(input) {
   }
   return hash >>> 0;
 }
+function fnv1a(input) {
+  return fnv1aBytes(encoder.encode(input));
+}
 
 // src/partitioning/router.ts
 function createPartitionRouter() {
@@ -8439,6 +8523,9 @@ function createFrozenDocTable(idTable, lengthColumns, documents, tombstones) {
     internalIdCapacity() {
       return capacity;
     },
+    contentBytes() {
+      return documents.byteLength;
+    },
     resolver() {
       return resolver;
     }
@@ -8466,21 +8553,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];
     }
@@ -10189,7 +10287,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;
@@ -10244,6 +10342,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) {
@@ -10288,8 +10387,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');
@@ -10307,10 +10409,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");
@@ -10344,6 +10450,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);
@@ -10354,10 +10466,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: [] };
@@ -10376,18 +10488,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 };
@@ -10587,9 +10701,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 };
   }
@@ -11018,6 +11147,19 @@ 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/vector/scalar-quantization-calibration.ts
 var PADDING_FACTOR = 0.01;
 function computeCalibrationBounds(vectors, dimensions) {
@@ -11247,7 +11389,7 @@ function createScalarQuantizer(dimensions, ordinalSource) {
   let liveCount = 0;
   let constants = deriveSq8Constants(0, 0, dimensions);
   let calibrated = false;
-  function ensureCapacity2(needed) {
+  function ensureCapacity3(needed) {
     if (needed <= capacity) return;
     let newCap = capacity === 0 ? INITIAL_CAPACITY2 : capacity;
     while (newCap < needed) newCap *= 2;
@@ -11377,7 +11519,7 @@ function createScalarQuantizer(dimensions, ordinalSource) {
       liveCount = 0;
       for (const [docId, vec] of collected) {
         const ord = resolveOrdinal(docId);
-        ensureCapacity2(ord + 1);
+        ensureCapacity3(ord + 1);
         quantizeInto(ord, vec);
         storeEntry(docId, ord);
       }
@@ -11387,7 +11529,7 @@ function createScalarQuantizer(dimensions, ordinalSource) {
         calibrateFromVectors([vector]);
       }
       const ord = resolveOrdinal(docId);
-      ensureCapacity2(ord + 1);
+      ensureCapacity3(ord + 1);
       quantizeInto(ord, vector);
       storeEntry(docId, ord);
     },
@@ -11454,7 +11596,7 @@ function createScalarQuantizer(dimensions, ordinalSource) {
     },
     restoreEntry(docId, quantized, sum, sumSq) {
       const ord = resolveOrdinal(docId);
-      ensureCapacity2(ord + 1);
+      ensureCapacity3(ord + 1);
       const base = ord * dimensions;
       quantizedArena.set(quantized.subarray(0, dimensions), base);
       sums[ord] = sum;
@@ -11605,7 +11747,7 @@ function createVectorStore() {
       arena = new Float32Array(simd.memory.buffer);
     }
   }
-  function ensureCapacity2(needed) {
+  function ensureCapacity3(needed) {
     if (needed <= capacity) return;
     let newCap = capacity === 0 ? INITIAL_CAPACITY3 : capacity;
     while (newCap < needed) newCap *= 2;
@@ -11687,7 +11829,7 @@ function createVectorStore() {
         recycledOrds.delete(docId);
         docToOrd.set(docId, recycled);
         ordToDoc[recycled] = docId;
-        ensureCapacity2(recycled + 1);
+        ensureCapacity3(recycled + 1);
         writeVector(recycled, vector);
         recordPartition(recycled, partitionId, false);
         liveCount++;
@@ -11696,7 +11838,7 @@ function createVectorStore() {
       const ord = ordToDoc.length;
       docToOrd.set(docId, ord);
       ordToDoc.push(docId);
-      ensureCapacity2(ord + 1);
+      ensureCapacity3(ord + 1);
       writeVector(ord, vector);
       recordPartition(ord, partitionId, false);
       liveCount++;
@@ -11862,7 +12004,7 @@ function createVectorStore() {
       }
       if (snapshot.dimension === 0 || snapshot.slots === 0) return;
       initStorage(snapshot.dimension);
-      ensureCapacity2(snapshot.slots);
+      ensureCapacity3(snapshot.slots);
       arena.set(snapshot.vectors.subarray(0, snapshot.slots * snapshot.dimension), scratchFloatLength);
       mags.set(snapshot.magnitudes.subarray(0, Math.min(snapshot.slots, mags.length)));
       ensurePartitionSlots(snapshot.slots);
@@ -13015,20 +13157,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) {
@@ -13039,18 +13204,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) {
@@ -13061,15 +13222,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)
       );
@@ -13092,7 +13260,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);
       });
@@ -13102,17 +13270,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,
@@ -14242,6 +14409,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();
     }
@@ -14365,6 +14535,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,
@@ -14530,7 +14706,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
   async function rebuildNow(indexName, entry) {
     const manager = deps.getManager(indexName);
     if (manager === void 0) {
-      stale.delete(indexName);
+      entry.run = null;
       return;
     }
     const partitionCount = manager.partitionCount;
@@ -14582,6 +14758,23 @@ function createAnalysisRebuildCoordinator(config, deps) {
     const documentCount = deps.getManager(indexName)?.countDocuments() ?? 0;
     await config?.onStaleAnalysis?.({ ...entry.index, documentCount }, () => enqueue2(indexName, entry));
   }
+  async function review(indexName, entry) {
+    if (entry.run !== null || deps.getManager(indexName) === void 0) return;
+    try {
+      await announce(indexName, entry);
+    } catch (err) {
+      deps.emit({
+        indexName,
+        status: "failed",
+        partitionsRebuilt: 0,
+        partitionCount: deps.getManager(indexName)?.partitionCount ?? 0,
+        error: toError(err)
+      });
+    }
+    if (rebuildMode === "auto") {
+      void enqueue2(indexName, entry).catch(() => void 0);
+    }
+  }
   return {
     markStale(index) {
       const existing = stale.get(index.indexName);
@@ -14596,23 +14789,16 @@ function createAnalysisRebuildCoordinator(config, deps) {
     isStale(indexName) {
       return stale.has(indexName);
     },
+    isRunning(indexName) {
+      return stale.get(indexName)?.run !== null && stale.get(indexName)?.run !== void 0;
+    },
+    review(indexName) {
+      const entry = stale.get(indexName);
+      return entry === void 0 ? Promise.resolve() : review(indexName, entry);
+    },
     async reviewStaleIndexes() {
       for (const [indexName, entry] of [...stale]) {
-        if (entry.run !== null) continue;
-        try {
-          await announce(indexName, entry);
-        } catch (err) {
-          deps.emit({
-            indexName,
-            status: "failed",
-            partitionsRebuilt: 0,
-            partitionCount: deps.getManager(indexName)?.partitionCount ?? 0,
-            error: toError(err)
-          });
-        }
-        if (rebuildMode === "auto") {
-          void enqueue2(indexName, entry).catch(() => void 0);
-        }
+        await review(indexName, entry);
       }
     },
     rebuild(indexName) {
@@ -15178,6 +15364,9 @@ function writeHeader(header) {
   }
   return buffer;
 }
+function hasNrslMagic(data) {
+  return data.length >= MAGIC_BYTES.length && data[0] === MAGIC_BYTES[0] && data[1] === MAGIC_BYTES[1] && data[2] === MAGIC_BYTES[2] && data[3] === MAGIC_BYTES[3];
+}
 function readHeader(data) {
   if (data.length < HEADER_SIZE) {
     throw new NarsilError(
@@ -15213,6 +15402,7 @@ function readHeader(data) {
 // src/serialization/envelope.ts
 var CURRENT_ENVELOPE_VERSION = 1;
 var SNAPSHOT_ENVELOPE_VERSION = 2;
+var INDEX_SNAPSHOT_ENVELOPE_VERSION = 3;
 function parseEngineVersion(version) {
   const parts = version.split(".");
   return [parseInt(parts[0] ?? "0", 10), parseInt(parts[1] ?? "0", 10), parseInt(parts[2] ?? "0", 10)];
@@ -15357,6 +15547,19 @@ function concatEnvelopeParts(parts) {
 async function unpackEnvelopeBytes(data) {
   return unpackEnvelope(data, SNAPSHOT_ENVELOPE_VERSION);
 }
+async function packIndexSnapshotEnvelope(payloadBytes) {
+  return packEnvelope(payloadBytes, { checksum: true, envelopeFormatVersion: INDEX_SNAPSHOT_ENVELOPE_VERSION });
+}
+async function unpackIndexSnapshotEnvelope(data) {
+  const { header, payloadBytes } = await unpackEnvelope(data, INDEX_SNAPSHOT_ENVELOPE_VERSION);
+  if (header.envelopeFormatVersion !== INDEX_SNAPSHOT_ENVELOPE_VERSION) {
+    throw new NarsilError(
+      ErrorCodes.ENVELOPE_VERSION_MISMATCH,
+      `Expected an index snapshot envelope of format v${INDEX_SNAPSHOT_ENVELOPE_VERSION}, received format v${header.envelopeFormatVersion}`
+    );
+  }
+  return payloadBytes;
+}
 async function writeMetadataEnvelope(meta, options = {}) {
   const payloadBytes = serializeMetadata(meta);
   return packEnvelope(payloadBytes, options);
@@ -16044,6 +16247,9 @@ function mergeTimeOrderedSegments(ordered, fallback) {
   validateMergedPartition(merged);
   return merged;
 }
+function countLiveDocuments(ordered) {
+  return resolveWinners(ordered).size;
+}
 function resolveWinners(ordered) {
   const winner = /* @__PURE__ */ new Map();
   for (let segIndex = 0; segIndex < ordered.length; segIndex += 1) {
@@ -17297,6 +17503,7 @@ async function writeSegmentedCheckpoint(input) {
     });
   }
   const partitions = [];
+  let wholeDocumentCount = input.wholePartitionPayload === void 0 ? null : 0;
   for (const target of input.targets) {
     const priorPartition = priorManifest?.partitions.find((p) => p.partitionId === target.partitionId);
     const priorSeqNo = snapshotCheckpointFor(priorManifest?.checkpoint ?? [], target.partitionId);
@@ -17307,15 +17514,13 @@ async function writeSegmentedCheckpoint(input) {
       priorSeqNo,
       target.lastSeqNo
     );
-    partitions.push(
-      input.wholePartitionPayload === void 0 ? await writePartition(context, target.partitionId, priorPartition, entries) : await writeWholePartition(
-        context,
-        target.partitionId,
-        priorPartition,
-        input.wholePartitionPayload(target.partitionId),
-        entries
-      )
-    );
+    if (input.wholePartitionPayload === void 0) {
+      partitions.push(await writePartition(context, target.partitionId, priorPartition, entries));
+    } else {
+      const whole = input.wholePartitionPayload(target.partitionId);
+      wholeDocumentCount = (wholeDocumentCount ?? 0) + whole.docCount;
+      partitions.push(await writeWholePartition(context, target.partitionId, priorPartition, whole, entries));
+    }
   }
   carryForwardUncheckpointedPartitions(priorManifest, input.targets, partitions, checkpointByPartition);
   const manifest = {
@@ -17327,6 +17532,7 @@ async function writeSegmentedCheckpoint(input) {
   const parts = await encodeSegmentManifest(manifest);
   await directory.atomicWrite(manifestKey(indexName), [parts.header, parts.payload]);
   await collectGarbage(directory, indexName, priorManifest, manifest);
+  return wholeDocumentCount;
 }
 async function writePartition(context, partitionId, priorPartition, entries) {
   let segments = priorPartition ? [...priorPartition.segments] : [];
@@ -17446,9 +17652,9 @@ async function writeIndexCheckpoint(input) {
   const { directory, metadata, targets, compactionThreshold, manager } = input;
   const offloaded = !input.fromMemory && input.canOffload && metadata.tokenizer === void 0 && metadata.stopWords === void 0 && await runCheckpointOnWorker({ root: directory.root, metadata, targets, compactionThreshold });
   if (offloaded) {
-    return;
+    return null;
   }
-  await writeSegmentedCheckpoint({
+  return writeSegmentedCheckpoint({
     directory,
     metadata,
     targets,
@@ -17480,9 +17686,171 @@ function createSeqOwner(startSeqNo, primaryTerm = SINGLE_NODE_PRIMARY_TERM) {
   };
 }
 
+// src/persistence/durability/checkpoint-run.ts
+function toError2(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+async function runDurableCheckpoint(input) {
+  const manager = input.hooks.getManager(input.indexName);
+  if (manager === void 0) {
+    return;
+  }
+  const metadata = input.hooks.buildMetadata(input.indexName);
+  if (metadata === void 0) {
+    return;
+  }
+  const targets = [];
+  const documentCount = manager.countDocuments();
+  for (let i = 0; i < manager.partitionCount; i += 1) {
+    const partition = input.indexState.partitions.get(i);
+    targets.push({
+      partitionId: i,
+      lastSeqNo: partition?.appliedSeqNo ?? 0,
+      primaryTerm: partition?.seqOwner.primaryTerm ?? SINGLE_NODE_PRIMARY_TERM
+    });
+  }
+  for (let i = 0; i < manager.partitionCount; i += 1) {
+    const partition = input.indexState.partitions.get(i);
+    if (partition === void 0) {
+      continue;
+    }
+    try {
+      await partition.walWriter.commit();
+    } catch (error) {
+      partition.failed = toError2(error);
+      input.markFatal(partition.failed);
+      throw partition.failed;
+    }
+  }
+  const writtenDocumentCount = await writeIndexCheckpoint({
+    directory: input.directory,
+    metadata,
+    targets,
+    compactionThreshold: input.compactionThreshold,
+    manager,
+    canOffload: input.canOffload,
+    fromMemory: input.fromMemory
+  });
+  const checkpointDocumentCount = writtenDocumentCount ?? documentCount;
+  await input.queueMetadataWrite(input.indexName, async () => {
+    const checkpointMetadata = input.hooks.buildMetadata(input.indexName, checkpointDocumentCount);
+    if (checkpointMetadata === void 0) {
+      return;
+    }
+    const bytes = await writeMetadataEnvelope(checkpointMetadata, { checksum: true });
+    await input.directory.atomicWrite(`${input.indexName}/meta`, bytes);
+    input.hooks.recordCheckpoint?.(input.indexName, checkpointDocumentCount, manager.partitionCount);
+  });
+  await truncateCoveredSegments(input.directory, input.indexName, targets);
+  await reclaimWalBeyondCount(
+    input.directory,
+    input.indexName,
+    manager.partitionCount,
+    input.indexState.partitions,
+    input.markFatal
+  );
+  input.indexState.mutationsSinceCheckpoint = 0;
+}
+
+// src/persistence/durability/manager-state.ts
+async function drainIndexStateForUnload(indexState, pendingMetadataWrite, closeWalWriter) {
+  indexState.unloading = true;
+  try {
+    if (indexState.checkpointInFlight !== null) await indexState.checkpointInFlight;
+    await pendingMetadataWrite;
+    for (const partition of indexState.partitions.values()) {
+      await closeWalWriter(partition.walWriter.close());
+    }
+  } catch (error) {
+    indexState.unloading = false;
+    throw error;
+  }
+}
+
+// src/persistence/durability/checkpoint-count.ts
+async function countCheckpointDocuments(directory, indexName) {
+  const manifest = await readSegmentManifest(directory, indexName);
+  if (manifest !== null) {
+    let total = 0;
+    for (const partition of manifest.partitions) {
+      const ordered = [];
+      for (const segment of partition.segments) {
+        ordered.push(await readSegmentContents(directory, segment.key));
+      }
+      total += countLiveDocuments(ordered);
+    }
+    return total;
+  }
+  const bytes = await directory.read(legacySnapshotKey(indexName));
+  if (bytes === null) {
+    return 0;
+  }
+  return countSnapshotBundleDocuments(bytes);
+}
+async function countSnapshotBundleDocuments(bytes) {
+  const bundle = await decodeSnapshotBundle(bytes);
+  let total = 0;
+  for (const partitionBytes of bundle.partitions) {
+    total += Object.keys(deserializePayloadV2(partitionBytes).documents).length;
+  }
+  return total;
+}
+
+// src/persistence/durability/recover-index.ts
+async function recoverPersistedIndex(deps, indexName, metadataOnly) {
+  const { directory, hooks } = deps;
+  const metadata = await loadMetadata(directory, indexName);
+  if (metadata === null) {
+    return;
+  }
+  let derivedCount;
+  if (metadataOnly && metadata.documentCount === void 0) {
+    try {
+      derivedCount = await countCheckpointDocuments(directory, indexName);
+      metadata.documentCount = derivedCount;
+    } catch {
+      derivedCount = void 0;
+    }
+  }
+  await hooks.createIndexFromMetadata(metadata, !metadataOnly);
+  if (metadataOnly) {
+    if (derivedCount !== void 0) {
+      await deps.queueMetadataWrite(indexName, async () => {
+        const upgraded = hooks.buildMetadata(indexName, derivedCount);
+        if (upgraded === void 0) {
+          return;
+        }
+        const bytes = await writeMetadataEnvelope(upgraded, { checksum: true });
+        await directory.atomicWrite(`${indexName}/meta`, bytes);
+      }).catch(() => void 0);
+    }
+    return;
+  }
+  const manager = hooks.getManager(indexName);
+  if (manager === void 0) {
+    return;
+  }
+  const replayDeps = {
+    manager,
+    vectorFieldPaths: hooks.getVectorFieldPaths(indexName),
+    vectorIndexes: hooks.getVectorIndexes(indexName)
+  };
+  const checkpoint = await loadSnapshot(directory, indexName, replayDeps);
+  const manifest = await readSegmentManifest(directory, indexName);
+  if (manifest !== null) {
+    await reclaimOrphanedSegments(directory, indexName, manifest);
+  }
+  for (let partitionId = 0; partitionId < manager.partitionCount; partitionId += 1) {
+    const fromSeqNo = snapshotCheckpointFor(checkpoint, partitionId);
+    const { highestSeqNo } = await replayWal(directory, indexName, partitionId, fromSeqNo, replayDeps);
+    deps.registerPartition(indexName, partitionId, highestSeqNo);
+  }
+}
+
 // src/persistence/durability/types.ts
 var DEFAULT_CHECKPOINT_INTERVAL_MS = 3e5;
 var DEFAULT_CHECKPOINT_MUTATION_THRESHOLD = 1e5;
+var DEFAULT_ASYNC_FLUSH_INTERVAL_MS = 1e3;
 
 // src/persistence/durability/group-commit.ts
 function createGroupCommitCoordinator(sync) {
@@ -17728,7 +18096,6 @@ function createWalWriter(directory, config) {
 }
 
 // src/persistence/durability/manager.ts
-var DEFAULT_ASYNC_FLUSH_INTERVAL_MS = 1e3;
 function createDurabilityManager(config, hooks, directoryOverride) {
   const directory = createDurableDirectory(config.directory ?? "");
   const canOffloadCheckpoint = directoryOverride === void 0;
@@ -17759,20 +18126,20 @@ function createDurabilityManager(config, hooks, directoryOverride) {
     }
     hooks.onFatalError(error);
   }
-  function toError3(err) {
+  function toError4(err) {
     return err instanceof Error ? err : new Error(String(err));
   }
   async function closeWriterReportingFailure(closePromise) {
     try {
       await closePromise;
     } catch (err) {
-      markFatal(toError3(err));
+      markFatal(toError4(err));
     }
   }
   function getOrCreateIndexState(indexName) {
     let state = indexes.get(indexName);
     if (state === void 0) {
-      state = { partitions: /* @__PURE__ */ new Map(), mutationsSinceCheckpoint: 0, checkpointInFlight: null };
+      state = { partitions: /* @__PURE__ */ new Map(), mutationsSinceCheckpoint: 0, checkpointInFlight: null, unloading: false };
       indexes.set(indexName, state);
     }
     return state;
@@ -17835,7 +18202,7 @@ function createDurabilityManager(config, hooks, directoryOverride) {
         try {
           await partition.walWriter.commit();
         } catch (err) {
-          partition.failed = toError3(err);
+          partition.failed = toError4(err);
           markFatal(partition.failed);
         }
       }
@@ -17849,7 +18216,7 @@ function createDurabilityManager(config, hooks, directoryOverride) {
       try {
         await checkpointIndex(indexName);
       } catch (err) {
-        markFatal(toError3(err));
+        markFatal(toError4(err));
       }
     }
   }
@@ -17866,7 +18233,7 @@ function createDurabilityManager(config, hooks, directoryOverride) {
   }
   async function checkpointIndex(indexName, fromMemory = false) {
     const indexState = indexes.get(indexName);
-    if (indexState === void 0) {
+    if (indexState === void 0 || indexState.unloading) {
       return;
     }
     if (indexState.checkpointInFlight !== null) {
@@ -17882,82 +18249,46 @@ function createDurabilityManager(config, hooks, directoryOverride) {
     return run;
   }
   async function performCheckpoint(indexName, indexState, fromMemory = false) {
-    const manager = hooks.getManager(indexName);
-    if (manager === void 0) {
-      return;
-    }
-    const metadata = hooks.buildMetadata(indexName);
-    if (metadata === void 0) {
-      return;
-    }
-    const targets = [];
-    for (let i = 0; i < manager.partitionCount; i += 1) {
-      const partition = indexState.partitions.get(i);
-      targets.push({
-        partitionId: i,
-        lastSeqNo: partition?.appliedSeqNo ?? 0,
-        primaryTerm: partition?.seqOwner.primaryTerm ?? SINGLE_NODE_PRIMARY_TERM
-      });
-      if (partition !== void 0) {
-        try {
-          await partition.walWriter.commit();
-        } catch (err) {
-          partition.failed = toError3(err);
-          markFatal(partition.failed);
-          throw partition.failed;
-        }
-      }
-    }
-    await writeIndexCheckpoint({
+    await runDurableCheckpoint({
       directory,
-      metadata,
-      targets,
+      hooks,
+      indexName,
+      indexState,
       compactionThreshold,
-      manager,
       canOffload: canOffloadCheckpoint,
-      fromMemory
+      fromMemory,
+      queueMetadataWrite,
+      markFatal
     });
-    await truncateCoveredSegments(directory, indexName, targets);
-    await reclaimWalBeyondCount(directory, indexName, manager.partitionCount, indexState.partitions, markFatal);
-    indexState.mutationsSinceCheckpoint = 0;
   }
-  async function recoverIndex(indexName) {
-    const metadata = await loadMetadata(directory, indexName);
-    if (metadata === null) {
-      return;
-    }
-    await hooks.createIndexFromMetadata(metadata);
-    const manager = hooks.getManager(indexName);
-    if (manager === void 0) {
-      return;
-    }
-    const deps = {
-      manager,
-      vectorFieldPaths: hooks.getVectorFieldPaths(indexName),
-      vectorIndexes: hooks.getVectorIndexes(indexName)
-    };
-    const checkpoint = await loadSnapshot(directory, indexName, deps);
-    const manifest = await readSegmentManifest(directory, indexName);
-    if (manifest !== null) {
-      await reclaimOrphanedSegments(directory, indexName, manifest);
-    }
-    for (let partitionId = 0; partitionId < manager.partitionCount; partitionId += 1) {
-      const fromSeqNo = snapshotCheckpointFor(checkpoint, partitionId);
-      const { highestSeqNo } = await replayWal(directory, indexName, partitionId, fromSeqNo, deps);
-      getOrCreatePartition(indexName, partitionId, highestSeqNo);
-    }
+  function recoverIndex(indexName, metadataOnly = false) {
+    return recoverPersistedIndex(
+      {
+        directory,
+        hooks,
+        registerPartition: (name, partitionId, startSeqNo) => {
+          getOrCreatePartition(name, partitionId, startSeqNo);
+        },
+        queueMetadataWrite
+      },
+      indexName,
+      metadataOnly
+    );
   }
   return {
     isActive() {
       return true;
     },
-    async recover() {
+    async recover(metadataOnly = false) {
       const names = await listPersistedIndexes(directory);
       for (const indexName of names) {
-        await recoverIndex(indexName);
+        await recoverIndex(indexName, metadataOnly);
       }
       startCheckpointTimer();
     },
+    recoverIndex(indexName) {
+      return recoverIndex(indexName);
+    },
     highestPersistedSeqNo(indexName, partitionId) {
       return indexes.get(indexName)?.partitions.get(partitionId)?.appliedSeqNo ?? 0;
     },
@@ -17981,7 +18312,7 @@ function createDurabilityManager(config, hooks, directoryOverride) {
           const entry = buildMutationEntry(record, allocatedSeqNo);
           await partition.walWriter.append(entry);
         } catch (err) {
-          partition.failed = toError3(err);
+          partition.failed = toError4(err);
           markFatal(partition.failed);
           throw partition.failed;
         }
@@ -17993,7 +18324,7 @@ function createDurabilityManager(config, hooks, directoryOverride) {
         try {
           await partition.walWriter.commit();
         } catch (err) {
-          partition.failed = toError3(err);
+          partition.failed = toError4(err);
           markFatal(partition.failed);
           throw partition.failed;
         }
@@ -18003,7 +18334,7 @@ function createDurabilityManager(config, hooks, directoryOverride) {
       startAsyncFlushTimer();
       if (indexState.mutationsSinceCheckpoint >= checkpointMutationThreshold) {
         void checkpointIndex(record.indexName).catch((err) => {
-          markFatal(toError3(err));
+          markFatal(toError4(err));
         });
       }
       return allocatedSeqNo;
@@ -18033,15 +18364,23 @@ function createDurabilityManager(config, hooks, directoryOverride) {
     async removeIndex(indexName) {
       const indexState = indexes.get(indexName);
       if (indexState !== void 0) {
-        for (const partition of indexState.partitions.values()) {
-          await closeWriterReportingFailure(partition.walWriter.close());
-        }
+        await drainIndexStateForUnload(indexState, metadataWrites.get(indexName), closeWriterReportingFailure);
         indexes.delete(indexName);
+        metadataWrites.delete(indexName);
       }
       for (const key of await directory.list(`${indexName}/`)) {
         await directory.remove(key);
       }
     },
+    async unloadIndex(indexName) {
+      const indexState = indexes.get(indexName);
+      if (indexState === void 0) {
+        return;
+      }
+      await drainIndexStateForUnload(indexState, metadataWrites.get(indexName), (close) => close);
+      indexes.delete(indexName);
+      metadataWrites.delete(indexName);
+    },
     async shutdown() {
       shuttingDown = true;
       if (checkpointTimer !== null) {
@@ -18080,7 +18419,13 @@ function createSnapshotOnlyManager(adapter, config, hooks, publisher) {
   function getOrCreateIndexState(indexName) {
     let state = indexes.get(indexName);
     if (state === void 0) {
-      state = { mutationsSinceCheckpoint: 0, checkpointInFlight: null, applyChain: Promise.resolve() };
+      state = {
+        mutationsSinceCheckpoint: 0,
+        checkpointInFlight: null,
+        applyChain: Promise.resolve(),
+        unloading: false,
+        appliedSeqNoByPartition: /* @__PURE__ */ new Map()
+      };
       indexes.set(indexName, state);
     }
     return state;
@@ -18111,10 +18456,11 @@ function createSnapshotOnlyManager(adapter, config, hooks, publisher) {
     if (manager === void 0 || metadata === void 0) {
       return;
     }
+    const documentCount = manager.countDocuments();
     const seqNoByPartition = /* @__PURE__ */ new Map();
     const primaryTermByPartition = /* @__PURE__ */ new Map();
     for (let i = 0; i < manager.partitionCount; i += 1) {
-      seqNoByPartition.set(i, 0);
+      seqNoByPartition.set(i, indexState.appliedSeqNoByPartition.get(i) ?? 0);
       primaryTermByPartition.set(i, SINGLE_NODE_PRIMARY_TERM);
     }
     const { parts } = await buildSnapshotBundleBytes({
@@ -18130,6 +18476,13 @@ function createSnapshotOnlyManager(adapter, config, hooks, publisher) {
       primaryTermByPartition
     });
     await adapter.save(snapshotStorageKey(indexName), concatEnvelopeParts(parts));
+    await queueMetadataWrite(indexName, async () => {
+      const checkpointMetadata = hooks.buildMetadata(indexName, documentCount);
+      if (checkpointMetadata === void 0) return;
+      const metadataBytes = await writeMetadataEnvelope(checkpointMetadata, { checksum: true });
+      await adapter.save(metadataKey(indexName), metadataBytes);
+      hooks.recordCheckpoint?.(indexName, documentCount, manager.partitionCount);
+    });
     indexState.mutationsSinceCheckpoint = 0;
     if (publisher !== void 0) {
       const partitionIds = [];
@@ -18139,15 +18492,18 @@ function createSnapshotOnlyManager(adapter, config, hooks, publisher) {
       await publisher.publishPartitions(indexName, partitionIds);
     }
   }
-  async function checkpointIndex(indexName) {
+  async function checkpointIndex(indexName, forceFresh = false) {
     const indexState = indexes.get(indexName);
-    if (indexState === void 0) {
+    if (indexState === void 0 || indexState.unloading) {
       return;
     }
     if (indexState.checkpointInFlight !== null) {
-      return indexState.checkpointInFlight;
+      await indexState.checkpointInFlight;
+      if (!forceFresh) {
+        return;
+      }
     }
-    const run = performCheckpoint(indexName, indexState).finally(() => {
+    const run = indexState.applyChain.then(() => performCheckpoint(indexName, indexState)).finally(() => {
       indexState.checkpointInFlight = null;
     });
     indexState.checkpointInFlight = run;
@@ -18162,13 +18518,35 @@ function createSnapshotOnlyManager(adapter, config, hooks, publisher) {
     );
     return queued;
   }
-  async function recoverIndex(indexName) {
+  async function recoverIndex(indexName, metadataOnly = false) {
     const metaBytes = await adapter.load(metadataKey(indexName));
     if (metaBytes === null) {
       return;
     }
     const { metadata } = await readMetadataEnvelope(metaBytes);
-    await hooks.createIndexFromMetadata(metadata);
+    let derivedCount;
+    if (metadataOnly && metadata.documentCount === void 0) {
+      try {
+        derivedCount = await countStoredBundleDocuments(indexName);
+        metadata.documentCount = derivedCount;
+      } catch {
+        derivedCount = void 0;
+      }
+    }
+    await hooks.createIndexFromMetadata(metadata, !metadataOnly);
+    if (metadataOnly) {
+      if (derivedCount !== void 0) {
+        await queueMetadataWrite(indexName, async () => {
+          const upgraded = hooks.buildMetadata(indexName, derivedCount);
+          if (upgraded === void 0) {
+            return;
+          }
+          const bytes = await writeMetadataEnvelope(upgraded, { checksum: true });
+          await adapter.save(metadataKey(indexName), bytes);
+        }).catch(() => void 0);
+      }
+      return;
+    }
     const manager = hooks.getManager(indexName);
     if (manager === void 0) {
       return;
@@ -18177,33 +18555,58 @@ function createSnapshotOnlyManager(adapter, config, hooks, publisher) {
     if (snapshotBytes === null) {
       return;
     }
-    await loadSnapshotBundleBytes(snapshotBytes, {
+    const checkpoint = await loadSnapshotBundleBytes(snapshotBytes, {
       manager,
       vectorFieldPaths: hooks.getVectorFieldPaths(indexName),
       vectorIndexes: hooks.getVectorIndexes(indexName)
     });
+    const indexState = getOrCreateIndexState(indexName);
+    for (let partitionId = 0; partitionId < manager.partitionCount; partitionId += 1) {
+      const persistedSeqNo = snapshotCheckpointFor(checkpoint, partitionId);
+      if (persistedSeqNo > 0) {
+        indexState.appliedSeqNoByPartition.set(partitionId, persistedSeqNo);
+      }
+    }
+  }
+  async function countStoredBundleDocuments(indexName) {
+    const snapshotBytes = await adapter.load(snapshotStorageKey(indexName));
+    if (snapshotBytes === null) {
+      return 0;
+    }
+    return countSnapshotBundleDocuments(snapshotBytes);
   }
   return {
     isActive() {
       return true;
     },
-    async recover() {
+    async recover(metadataOnly = false) {
       const keys = await adapter.list("");
       for (const key of keys) {
         if (key.endsWith("/meta")) {
-          await recoverIndex(key.slice(0, -"/meta".length));
+          await recoverIndex(key.slice(0, -"/meta".length), metadataOnly);
         }
       }
       startCheckpointTimer();
     },
-    highestPersistedSeqNo() {
-      return 0;
+    recoverIndex(indexName) {
+      return recoverIndex(indexName);
+    },
+    highestPersistedSeqNo(indexName, partitionId) {
+      return indexes.get(indexName)?.appliedSeqNoByPartition.get(partitionId) ?? 0;
     },
     async recordMutation(record) {
       const indexState = getOrCreateIndexState(record.indexName);
-      const buffered = indexState.applyChain.then(() => record.apply());
-      indexState.applyChain = buffered.catch(() => void 0);
-      await buffered;
+      const buffered = indexState.applyChain.then(async () => {
+        await record.apply();
+        const appliedSeqNo2 = (indexState.appliedSeqNoByPartition.get(record.partitionId) ?? 0) + 1;
+        indexState.appliedSeqNoByPartition.set(record.partitionId, appliedSeqNo2);
+        return appliedSeqNo2;
+      });
+      indexState.applyChain = buffered.then(
+        () => void 0,
+        () => void 0
+      );
+      const appliedSeqNo = await buffered;
       indexState.mutationsSinceCheckpoint += 1;
       startCheckpointTimer();
       if (indexState.mutationsSinceCheckpoint >= checkpointMutationThreshold) {
@@ -18211,7 +18614,7 @@ function createSnapshotOnlyManager(adapter, config, hooks, publisher) {
           hooks.onFatalError(err instanceof Error ? err : new Error(String(err)));
         });
       }
-      return 0;
+      return appliedSeqNo;
     },
     persistMetadata(indexName) {
       return queueMetadataWrite(indexName, async () => {
@@ -18227,17 +18630,49 @@ function createSnapshotOnlyManager(adapter, config, hooks, publisher) {
     checkpoint(indexName) {
       return checkpointIndex(indexName);
     },
+    checkpointFromMemory(indexName) {
+      return checkpointIndex(indexName, true);
+    },
     async checkpointAll() {
       for (const indexName of [...indexes.keys()]) {
         await checkpointIndex(indexName);
       }
     },
     async removeIndex(indexName) {
+      const indexState = indexes.get(indexName);
+      if (indexState !== void 0) {
+        indexState.unloading = true;
+        try {
+          await indexState.applyChain;
+          if (indexState.checkpointInFlight !== null) await indexState.checkpointInFlight;
+          await metadataWrites.get(indexName);
+        } catch (error) {
+          indexState.unloading = false;
+          throw error;
+        }
+      }
       indexes.delete(indexName);
+      metadataWrites.delete(indexName);
       for (const key of await adapter.list(`${indexName}/`)) {
         await adapter.delete(key);
       }
     },
+    async unloadIndex(indexName) {
+      const indexState = indexes.get(indexName);
+      if (indexState !== void 0) {
+        indexState.unloading = true;
+        try {
+          await indexState.applyChain;
+          if (indexState.checkpointInFlight !== null) await indexState.checkpointInFlight;
+          await metadataWrites.get(indexName);
+        } catch (error) {
+          indexState.unloading = false;
+          throw error;
+        }
+      }
+      indexes.delete(indexName);
+      metadataWrites.delete(indexName);
+    },
     async reloadIndex(indexName) {
       const indexState = getOrCreateIndexState(indexName);
       const reload = indexState.applyChain.then(() => recoverIndex(indexName));
@@ -18261,21 +18696,22 @@ function createSnapshotOnlyManager(adapter, config, hooks, publisher) {
 }
 
 // src/engine/durability-integration.ts
-function buildMetadata(indexName, hooks) {
+function buildMetadata(indexName, hooks, documentCount) {
   const config = hooks.getIndexConfig(indexName);
   const manager = hooks.getManager(indexName);
-  if (config === void 0 || manager === void 0) {
+  if (config === void 0) {
     return void 0;
   }
   const metadata = {
     indexName,
     schema: config.schema,
     language: config.language,
-    partitionCount: manager.partitionCount,
+    partitionCount: manager?.partitionCount ?? config.partitionCount,
     bm25Params: { k1: config.k1, b: config.b },
     createdAt: Date.now(),
     engineVersion: VERSION
   };
+  metadata.documentCount = documentCount ?? config.documentCount;
   if (config.embedding) {
     metadata.embedding = config.embedding;
   }
@@ -18325,8 +18761,9 @@ function createDurabilityIntegration(tier, hooks) {
     getManager: hooks.getManager,
     getVectorFieldPaths: hooks.getVectorFieldPaths,
     getVectorIndexes: hooks.getVectorIndexes,
-    buildMetadata: (indexName) => buildMetadata(indexName, hooks),
+    buildMetadata: (indexName, documentCount) => buildMetadata(indexName, hooks, documentCount),
     createIndexFromMetadata: hooks.createIndexFromMetadata,
+    recordCheckpoint: hooks.recordCheckpoint,
     onFatalError: hooks.onFatalError
   };
   const manager = tier.kind === "wal" ? createDurabilityManager(tier.config, managerHooks) : createSnapshotOnlyManager(tier.adapter, tier.config, managerHooks, hooks.checkpointPublisher);
@@ -18365,9 +18802,9 @@ function createDurabilityFromTier(tier, wiring) {
   }
   return createDurabilityIntegration(tier, {
     checkpointPublisher: { publishPartitions: wiring.publishCheckpointedPartitions },
-    getManager: (indexName) => wiring.indexRegistry.has(indexName) ? wiring.requireManager(indexName) : void 0,
+    getManager: (indexName) => wiring.indexRegistry.has(indexName) ? wiring.getManager(indexName) : void 0,
     getVectorFieldPaths: (indexName) => wiring.indexRegistry.get(indexName)?.vectorFieldPaths ?? /* @__PURE__ */ new Set(),
-    getVectorIndexes: (indexName) => wiring.indexRegistry.has(indexName) ? wiring.requireManager(indexName).getVectorIndexes() : /* @__PURE__ */ new Map(),
+    getVectorIndexes: (indexName) => (wiring.indexRegistry.has(indexName) ? wiring.getManager(indexName)?.getVectorIndexes() : void 0) ?? /* @__PURE__ */ new Map(),
     getIndexConfig: (indexName) => {
       const entry = wiring.indexRegistry.get(indexName);
       if (entry === void 0) {
@@ -18380,6 +18817,8 @@ function createDurabilityFromTier(tier, wiring) {
       return {
         ...entry.indexUuid !== null ? { indexUuid: entry.indexUuid } : {},
         ...entry.heldPartitions !== null ? { heldPartitions: entry.heldPartitions } : {},
+        documentCount: entry.documentCount,
+        partitionCount: entry.partitionCount,
         schema: flattenSchema(entry.config.schema),
         language: entry.language.name,
         k1: entry.config.bm25?.k1 ?? 1.2,
@@ -18399,10 +18838,401 @@ function createDurabilityFromTier(tier, wiring) {
       };
     },
     createIndexFromMetadata: wiring.createIndexFromMetadata,
+    recordCheckpoint: wiring.recordCheckpoint,
     onFatalError: wiring.emitFatalError
   });
 }
 
+// src/engine/index-state/entry.ts
+var DEFAULT_MAX_REOPEN_WAITERS = 64;
+var MAX_REOPEN_FAILURES = 5;
+var MIN_SWEEP_INTERVAL_MS = 100;
+var MAX_SWEEP_INTERVAL_MS = 6e4;
+function createLifecycleEntry(state) {
+  return {
+    state,
+    lastAccessAt: Date.now(),
+    activeOperations: 0,
+    reopenCount: 0,
+    reopenFailures: 0,
+    nextReopenAt: 0,
+    cachedError: null,
+    reopenPromise: null,
+    waiterCount: 0,
+    closePromise: null,
+    dropPromise: null,
+    drainResolvers: /* @__PURE__ */ new Set()
+  };
+}
+function validateLimit(name, value, allowZero = false) {
+  if (value === void 0) return;
+  const minimum = allowZero ? 0 : 1;
+  if (!Number.isSafeInteger(value) || value < minimum) {
+    const requirement = allowZero ? "a non-negative safe integer" : "a positive safe integer";
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, `${name} must be ${requirement}`, {
+      field: name,
+      value
+    });
+  }
+}
+function cachedRecoveryError(error, indexName) {
+  if (error instanceof NarsilError) return error;
+  return new NarsilError(ErrorCodes.PERSISTENCE_LOAD_FAILED, `Index "${indexName}" could not be reopened`, {
+    indexName,
+    cause: error instanceof Error ? error.message : String(error)
+  });
+}
+
+// src/engine/index-state/index.ts
+function createIndexStateCoordinator(config, callbacks) {
+  validateLimit("lifecycle.idleTimeoutMs", config?.idleTimeoutMs);
+  validateLimit("lifecycle.maxOpenIndexes", config?.maxOpenIndexes);
+  validateLimit("lifecycle.maxOpenBytes", config?.maxOpenBytes);
+  validateLimit("lifecycle.maxReopenWaiters", config?.maxReopenWaiters, true);
+  const entries = /* @__PURE__ */ new Map();
+  const waiterLimit = config?.maxReopenWaiters ?? DEFAULT_MAX_REOPEN_WAITERS;
+  let sweepTimer = null;
+  function entryOf(indexName) {
+    const entry = entries.get(indexName);
+    if (entry === void 0) {
+      throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Index "${indexName}" does not exist`, { indexName });
+    }
+    return entry;
+  }
+  function publicState(entry) {
+    return entry.state === "closing" || entry.state === "dropping" ? "open" : entry.state;
+  }
+  async function waitForDrain(entry) {
+    if (entry.activeOperations === 0) return;
+    await new Promise((resolve) => entry.drainResolvers.add(resolve));
+  }
+  function markClosed(entry) {
+    entry.state = "closed";
+    entry.cachedError = null;
+    entry.reopenFailures = 0;
+  }
+  function releaseEntry(entry) {
+    entry.activeOperations -= 1;
+    if (entry.activeOperations !== 0) return;
+    for (const resolve of entry.drainResolvers) resolve();
+    entry.drainResolvers.clear();
+  }
+  async function waitForTransition(indexName, entry, transition) {
+    if (entry.waiterCount >= waiterLimit) {
+      throw new NarsilError(
+        ErrorCodes.INDEX_REOPEN_CAPACITY_EXHAUSTED,
+        `Index "${indexName}" has reached its reopen waiter limit`,
+        { indexName, maximum: waiterLimit }
+      );
+    }
+    entry.waiterCount += 1;
+    try {
+      await transition;
+    } finally {
+      entry.waiterCount -= 1;
+    }
+  }
+  async function awaitPendingTransitions(indexName) {
+    let entry = entryOf(indexName);
+    while (true) {
+      if (entry.state === "dropping" && entry.dropPromise !== null) {
+        await entry.dropPromise;
+        entry = entryOf(indexName);
+        continue;
+      }
+      if (entry.state === "closing" && entry.closePromise !== null) {
+        await waitForTransition(
+          indexName,
+          entry,
+          entry.closePromise.catch(() => void 0)
+        );
+        entry = entryOf(indexName);
+        continue;
+      }
+      return entry;
+    }
+  }
+  async function reopen(indexName, explicit) {
+    const entry = await awaitPendingTransitions(indexName);
+    if (entry.state === "open") return;
+    if (explicit) {
+      entry.reopenFailures = 0;
+      entry.nextReopenAt = 0;
+      entry.cachedError = null;
+      if (entry.state === "reopen-failed") entry.state = "closed";
+    }
+    if (entry.state === "reopen-failed") throw entry.cachedError;
+    if (entry.reopenPromise !== null) {
+      await waitForTransition(indexName, entry, entry.reopenPromise);
+      return;
+    }
+    if (!explicit && entry.cachedError !== null && Date.now() < entry.nextReopenAt) {
+      throw entry.cachedError;
+    }
+    const run = callbacks.reopen(indexName).then(() => {
+      entry.state = "open";
+      entry.reopenCount += 1;
+      entry.reopenFailures = 0;
+      entry.nextReopenAt = 0;
+      entry.cachedError = null;
+    }).catch((error) => {
+      entry.reopenFailures += 1;
+      entry.cachedError = cachedRecoveryError(error, indexName);
+      entry.nextReopenAt = Date.now() + 100 * 2 ** (entry.reopenFailures - 1);
+      entry.state = entry.reopenFailures >= MAX_REOPEN_FAILURES ? "reopen-failed" : "closed";
+      throw entry.cachedError;
+    }).finally(() => {
+      entry.reopenPromise = null;
+    });
+    entry.reopenPromise = run;
+    await run;
+  }
+  async function closeEntry(indexName, automatic) {
+    let entry = entryOf(indexName);
+    while (true) {
+      if (entry.state === "dropping" && entry.dropPromise !== null) {
+        if (automatic) return false;
+        await entry.dropPromise;
+        entry = entryOf(indexName);
+        continue;
+      }
+      if (entry.reopenPromise !== null) {
+        if (automatic) return false;
+        await entry.reopenPromise.catch(() => void 0);
+        entry = entryOf(indexName);
+        continue;
+      }
+      break;
+    }
+    if (entry.state === "closed" || entry.state === "reopen-failed") return true;
+    if (entry.state === "closing" && entry.closePromise !== null) {
+      if (!automatic) await entry.closePromise;
+      return !automatic;
+    }
+    if (automatic && (entry.activeOperations > 0 || !callbacks.canCloseAutomatically(indexName))) return false;
+    entry.state = "closing";
+    let irreversible = false;
+    const run = (async () => {
+      await waitForDrain(entry);
+      await callbacks.close(indexName, () => {
+        irreversible = true;
+      });
+      markClosed(entry);
+    })().catch((error) => {
+      if (irreversible) markClosed(entry);
+      else entry.state = "open";
+      throw error;
+    }).finally(() => {
+      entry.closePromise = null;
+    });
+    entry.closePromise = run;
+    if (automatic) {
+      await run.catch(() => void 0);
+      return publicState(entry) === "closed";
+    }
+    await run;
+    return true;
+  }
+  async function dropEntry(indexName, action) {
+    let entry = entryOf(indexName);
+    while (true) {
+      if (entry.dropPromise !== null) {
+        await entry.dropPromise;
+        return;
+      }
+      if (entry.reopenPromise !== null) {
+        await entry.reopenPromise.catch(() => void 0);
+        entry = entryOf(indexName);
+        continue;
+      }
+      if (entry.closePromise !== null) {
+        await entry.closePromise.catch(() => void 0);
+        entry = entryOf(indexName);
+        continue;
+      }
+      break;
+    }
+    const previousState = entry.state;
+    entry.state = "dropping";
+    const run = (async () => {
+      await waitForDrain(entry);
+      await action();
+      entries.delete(indexName);
+    })().catch((error) => {
+      entry.state = previousState;
+      throw error;
+    }).finally(() => {
+      entry.dropPromise = null;
+    });
+    entry.dropPromise = run;
+    await run;
+  }
+  function exceedsLimits() {
+    let open = 0;
+    let bytes = 0;
+    for (const [name, entry] of entries) {
+      if (entry.state !== "open") continue;
+      open += 1;
+      bytes += callbacks.estimateBytes(name);
+    }
+    return config?.maxOpenIndexes !== void 0 && open > config.maxOpenIndexes || config?.maxOpenBytes !== void 0 && bytes > config.maxOpenBytes;
+  }
+  async function enforceLimits(protectedName) {
+    if (config?.maxOpenIndexes === void 0 && config?.maxOpenBytes === void 0) return;
+    while (exceedsLimits()) {
+      const candidates = [...entries].filter(([name, entry]) => name !== protectedName && entry.state === "open" && entry.activeOperations === 0).sort((left, right) => left[1].lastAccessAt - right[1].lastAccessAt);
+      const candidate = candidates[0];
+      if (candidate === void 0 || !await closeEntry(candidate[0], true)) return;
+    }
+  }
+  async function sweep() {
+    const timeout = config?.idleTimeoutMs;
+    if (timeout !== void 0 && timeout > 0) {
+      const cutoff = Date.now() - timeout;
+      for (const [name, entry] of entries) {
+        if (entry.state === "open" && entry.lastAccessAt <= cutoff) await closeEntry(name, true);
+      }
+    }
+    await enforceLimits();
+  }
+  if (config !== void 0) {
+    const requested = config.idleTimeoutMs === void 0 ? MAX_SWEEP_INTERVAL_MS : config.idleTimeoutMs / 2;
+    const interval = Math.min(MAX_SWEEP_INTERVAL_MS, Math.max(MIN_SWEEP_INTERVAL_MS, requested));
+    sweepTimer = setInterval(() => void sweep().catch(() => void 0), interval);
+    if (typeof sweepTimer.unref === "function") sweepTimer.unref();
+  }
+  return {
+    async registerOpen(indexName) {
+      entries.set(indexName, createLifecycleEntry("open"));
+      await enforceLimits(indexName);
+    },
+    registerClosed(indexName) {
+      entries.set(indexName, createLifecycleEntry("closed"));
+    },
+    forget(indexName) {
+      entries.delete(indexName);
+    },
+    async acquire(indexName, markActive = true) {
+      let entry = entryOf(indexName);
+      const opened = entry.state !== "open";
+      await reopen(indexName, false);
+      entry = entryOf(indexName);
+      while (entry.state !== "open") {
+        await reopen(indexName, false);
+        entry = entryOf(indexName);
+      }
+      if (markActive) entry.lastAccessAt = Date.now();
+      entry.activeOperations += 1;
+      try {
+        if (opened) await enforceLimits(indexName);
+      } catch (error) {
+        releaseEntry(entry);
+        throw error;
+      }
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        releaseEntry(entry);
+      };
+    },
+    async open(indexName) {
+      await reopen(indexName, true);
+      let entry = entryOf(indexName);
+      while (entry.state !== "open") {
+        await reopen(indexName, true);
+        entry = entryOf(indexName);
+      }
+      entry.lastAccessAt = Date.now();
+      entry.activeOperations += 1;
+      try {
+        await enforceLimits(indexName);
+      } finally {
+        releaseEntry(entry);
+      }
+    },
+    async close(indexName) {
+      await closeEntry(indexName, false);
+    },
+    drop(indexName, action) {
+      return dropEntry(indexName, action);
+    },
+    stateOf(indexName) {
+      return publicState(entryOf(indexName));
+    },
+    reopenCount(indexName) {
+      return entryOf(indexName).reopenCount;
+    },
+    counts() {
+      let open = 0;
+      let closed = 0;
+      let reopens = 0;
+      for (const entry of entries.values()) {
+        if (entry.state === "open" || entry.state === "closing") open += 1;
+        else closed += 1;
+        reopens += entry.reopenCount;
+      }
+      return { open, closed, reopens };
+    },
+    dispose() {
+      if (sweepTimer !== null) clearInterval(sweepTimer);
+      sweepTimer = null;
+      entries.clear();
+    }
+  };
+}
+
+// src/engine/index-state-wiring.ts
+function wireIndexState(wiring) {
+  const { durability, executor, orchestrator, analysisRebuild, indexRegistry, rebalancingIndexes } = wiring;
+  return createIndexStateCoordinator(wiring.config, {
+    async reopen(indexName) {
+      if (durability === null) {
+        throw new NarsilError(ErrorCodes.CONFIG_INVALID, "An index needs durability before it can reopen");
+      }
+      try {
+        await durability.manager.recoverIndex(indexName);
+        await analysisRebuild.review(indexName);
+        await orchestrator.openIndex(indexName);
+        await wiring.onOpen?.(indexName);
+      } catch (error) {
+        await orchestrator.closeIndex(indexName).catch(() => void 0);
+        await durability.manager.unloadIndex(indexName).catch(() => void 0);
+        if (executor.getManager(indexName) !== void 0) executor.dropIndex(indexName);
+        throw error;
+      }
+    },
+    async close(indexName, markIrreversible) {
+      if (durability === null) {
+        throw new NarsilError(ErrorCodes.CONFIG_INVALID, "An index needs durability before it can close");
+      }
+      const manager = wiring.requireManager(indexName);
+      const documentCount = manager.countDocuments();
+      const partitionCount = manager.partitionCount;
+      await (durability.manager.checkpointFromMemory?.(indexName) ?? durability.manager.checkpoint(indexName));
+      await orchestrator.closeIndex(indexName);
+      await durability.manager.unloadIndex(indexName);
+      markIrreversible();
+      try {
+        await wiring.onClose?.(indexName);
+      } finally {
+        if (executor.getManager(indexName) !== void 0) executor.dropIndex(indexName);
+        const entry = indexRegistry.get(indexName);
+        if (entry !== void 0) {
+          entry.documentCount = documentCount;
+          entry.partitionCount = partitionCount;
+        }
+      }
+    },
+    canCloseAutomatically(indexName) {
+      return !rebalancingIndexes.has(indexName) && !analysisRebuild.isRunning(indexName) && !orchestrator.isIndexBusy(indexName);
+    },
+    estimateBytes(indexName) {
+      return executor.getManager(indexName)?.estimateMemoryBytes() ?? 0;
+    }
+  });
+}
+
 // src/engine/invalidation.ts
 var STATISTICS_BROADCAST_INTERVAL_MS = 5e3;
 var FOREIGN_STATS_TTL_MS = 6e4;
@@ -18428,7 +19258,7 @@ function createInvalidationIntegration(deps) {
   const reloadChains = /* @__PURE__ */ new Map();
   let broadcastTimer = null;
   let stopped = false;
-  function toError3(err) {
+  function toError4(err) {
     return err instanceof Error ? err : new Error(String(err));
   }
   function pruneStaleForeignStats(entries) {
@@ -18441,7 +19271,7 @@ function createInvalidationIntegration(deps) {
   }
   function scheduleReload(indexName) {
     const chain = reloadChains.get(indexName) ?? Promise.resolve();
-    const next = chain.then(() => reloadIndex(indexName)).catch((err) => onError(toError3(err)));
+    const next = chain.then(() => reloadIndex(indexName)).catch((err) => onError(toError4(err)));
     reloadChains.set(indexName, next);
   }
   function storeForeignStats(indexName, sourceInstanceId, stats) {
@@ -18467,7 +19297,7 @@ function createInvalidationIntegration(deps) {
       }
       storeForeignStats(event.indexName, event.instanceId, event.stats);
     } catch (err) {
-      onError(toError3(err));
+      onError(toError4(err));
     }
   }
   async function publishOwnStatistics() {
@@ -18489,7 +19319,7 @@ function createInvalidationIntegration(deps) {
           }
         });
       } catch (err) {
-        onError(toError3(err));
+        onError(toError4(err));
       }
     }
   }
@@ -18508,7 +19338,7 @@ function createInvalidationIntegration(deps) {
           sourceInstanceId: instanceId
         });
       } catch (err) {
-        onError(toError3(err));
+        onError(toError4(err));
       }
     },
     broadcastStats(indexName) {
@@ -18553,7 +19383,7 @@ function createInvalidationIntegration(deps) {
       try {
         await adapter.shutdown();
       } catch (err) {
-        onError(toError3(err));
+        onError(toError4(err));
       }
     }
   };
@@ -18595,7 +19425,7 @@ async function transferIndexToPool(indexName, pool, config, manager) {
 }
 
 // src/engine/orchestration/eligibility.ts
-function toError2(value) {
+function toError3(value) {
   return value instanceof Error ? value : new Error(String(value));
 }
 function isDeterministicFailure(error) {
@@ -18933,14 +19763,34 @@ async function awaitCompactions(state) {
 var DEFAULT_BACKPRESSURE_LIMIT = 100;
 var DEFAULT_REQUEST_TIMEOUT = 3e4;
 var SHUTDOWN_TIMEOUT = 5e3;
+var CONSECUTIVE_TIMEOUTS_BEFORE_DEATH = 3;
+function errorFromEventLike(event) {
+  if (event instanceof Error) {
+    return event;
+  }
+  if (typeof event === "object" && event !== null) {
+    const detail = event;
+    if (detail.error instanceof Error) {
+      return detail.error;
+    }
+    if (typeof detail.message === "string" && detail.message.length > 0) {
+      return new Error(detail.message);
+    }
+  }
+  return new Error("The worker reported an error event carrying no detail");
+}
 function createWorkerExecutor(worker, config) {
-  const backpressureLimit = DEFAULT_BACKPRESSURE_LIMIT;
-  const requestTimeout = DEFAULT_REQUEST_TIMEOUT;
+  const backpressureLimit = config?.backpressureLimit ?? DEFAULT_BACKPRESSURE_LIMIT;
+  const requestTimeout = config?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
   const pending = /* @__PURE__ */ new Map();
+  let deathError = null;
+  let shutdownRequested = false;
+  let consecutiveTimeouts = 0;
   function processResponse(msg) {
     if (!isValidWorkerResponse(msg)) {
       return;
     }
+    consecutiveTimeouts = 0;
     const response = msg;
     const entry = pending.get(response.requestId);
     if (!entry) {
@@ -18954,15 +19804,36 @@ function createWorkerExecutor(worker, config) {
       entry.resolve(response.data);
     }
   }
+  function handleDeath(cause) {
+    if (deathError !== null) {
+      return;
+    }
+    const message = cause instanceof Error ? cause.message : String(cause);
+    deathError = new NarsilError(ErrorCodes.WORKER_CRASHED, `Worker died: ${message}`);
+    for (const [id, entry] of pending) {
+      clearTimeout(entry.timeoutId);
+      entry.reject(deathError);
+      pending.delete(id);
+    }
+    if (!shutdownRequested) {
+      config?.onDeath?.(cause instanceof Error ? cause : new Error(message));
+    }
+  }
   if (typeof worker.on === "function") {
     worker.on("message", (msg) => processResponse(msg));
+    worker.on("error", (cause) => handleDeath(cause));
+    worker.on("exit", (code) => handleDeath(new Error(`Worker exited with code ${String(code)}`)));
   } else if (typeof worker.addEventListener === "function") {
     worker.addEventListener("message", (event) => {
       const msg = event.data;
       processResponse(msg);
     });
+    worker.addEventListener("error", (event) => handleDeath(errorFromEventLike(event)));
   }
   function execute(action) {
+    if (deathError !== null) {
+      return Promise.reject(deathError);
+    }
     if (pending.size >= backpressureLimit) {
       return Promise.reject(
         new NarsilError(ErrorCodes.WORKER_BUSY, `Backpressure limit of ${backpressureLimit} pending requests reached`)
@@ -18974,6 +19845,10 @@ function createWorkerExecutor(worker, config) {
       const timeoutId = setTimeout(() => {
         pending.delete(requestId);
         reject2(new NarsilError(ErrorCodes.WORKER_TIMEOUT, `Request ${requestId} timed out after ${requestTimeout}ms`));
+        consecutiveTimeouts += 1;
+        if (consecutiveTimeouts >= CONSECUTIVE_TIMEOUTS_BEFORE_DEATH) {
+          handleDeath(new Error(`no answer to ${CONSECUTIVE_TIMEOUTS_BEFORE_DEATH} consecutive requests`));
+        }
       }, requestTimeout);
       pending.set(requestId, {
         resolve,
@@ -18984,6 +19859,10 @@ function createWorkerExecutor(worker, config) {
     });
   }
   async function shutdown() {
+    shutdownRequested = true;
+    if (deathError !== null) {
+      return;
+    }
     const requestId = createRequestId();
     const shutdownAction = { type: "shutdown", requestId };
     const shutdownPromise = new Promise((resolve, reject2) => {
@@ -19024,9 +19903,9 @@ async function createWorkerFactory(entryPoint) {
   const runtime = detectRuntime();
   const resolvedEntry = resolveEntryPoint();
   if (runtime.supportsWebWorkers) {
-    return function webFactory(_workerId) {
+    return function webFactory(_workerId, onDeath) {
       const instance = new Worker(resolvedEntry, { type: "module" });
-      return createWorkerExecutor(instance);
+      return createWorkerExecutor(instance, { onDeath });
     };
   }
   throw new NarsilError(ErrorCodes.WORKER_CRASHED, `No worker support available on runtime "${runtime.runtime}"`);
@@ -19082,7 +19961,13 @@ async function runPromotion(state, reason) {
       return;
     }
     const factory = await createWorkerFactory();
-    const pool = createWorkerPool({ count: state.config?.workers?.count, workerFactory: factory });
+    const pool = createWorkerPool({
+      count: state.config?.workers?.count,
+      workerFactory: factory,
+      onWorkerCrash(workerId, indexNames, error) {
+        state.callbacks?.onWorkerCrash?.(workerId, indexNames, error);
+      }
+    });
     for (const name of promotable) {
       pool.addIndexToAll(name);
     }
@@ -19119,7 +20004,7 @@ async function promoteBeforeBatch(state, indexName, incomingCount) {
   if (!result.shouldPromote) return;
   state.promotionInProgress = true;
   const run = runPromotion(state, result.reason).catch((err) => {
-    const error = toError2(err);
+    const error = toError3(err);
     state.promotionBlocked = isDeterministicFailure(error);
     state.promotionInProgress = false;
     state.callbacks?.onPromotionFailure?.(result.reason, error, !state.promotionBlocked);
@@ -19140,7 +20025,7 @@ async function checkPromotion(state) {
   state.promotionInProgress = true;
   setTimeout(() => {
     const run = runPromotion(state, result.reason).catch((err) => {
-      const error = toError2(err);
+      const error = toError3(err);
       state.promotionBlocked = isDeterministicFailure(error);
       state.promotionInProgress = false;
       state.callbacks?.onPromotionFailure?.(result.reason, error, !state.promotionBlocked);
@@ -19310,6 +20195,56 @@ function createWorkerOrchestrator(config, executor, promoter, indexRegistry, cal
       state.segmentLedger.clear();
     }
   }
+  async function awaitPromotionIdle() {
+    while (state.promotionInProgress) {
+      const run = state.promotionRun;
+      if (run !== null) {
+        await run;
+      } else {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      }
+    }
+  }
+  async function closeIndex(indexName) {
+    await awaitPromotionIdle();
+    await awaitReplicationIdle(state, indexName);
+    await awaitCompactions(state);
+    const pool = state.workerPool;
+    if (pool !== null && state.promotedIndexes.has(indexName)) {
+      const outcomes = await Promise.allSettled(
+        pool.getAllExecutors().map((worker) => worker.execute({ type: "dropIndex", indexName, requestId: `close-${indexName}` }))
+      );
+      const failure = outcomes.find((outcome) => outcome.status === "rejected");
+      if (failure?.status === "rejected") {
+        const entry = indexRegistry.get(indexName);
+        const manager = executor.getManager(indexName);
+        if (entry !== void 0 && manager !== void 0) {
+          try {
+            await transferIndexToPool(indexName, pool, entry.config, manager);
+          } catch (repairError) {
+            throw new NarsilError(
+              ErrorCodes.WORKER_CRASHED,
+              `Worker copies for index "${indexName}" could not be restored after close failed`,
+              {
+                indexName,
+                closeError: failure.reason instanceof Error ? failure.reason.message : String(failure.reason),
+                repairError: repairError instanceof Error ? repairError.message : String(repairError)
+              }
+            );
+          }
+        }
+        if (failure.reason instanceof NarsilError) throw failure.reason;
+        throw new NarsilError(ErrorCodes.WORKER_CRASHED, `A worker could not close index "${indexName}"`, {
+          indexName,
+          cause: failure.reason instanceof Error ? failure.reason.message : String(failure.reason)
+        });
+      }
+      pool.removeIndex(indexName);
+    }
+    state.promotedIndexes.delete(indexName);
+    state.replicationQueues.delete(indexName);
+    state.segmentLedger.delete(indexName);
+  }
   async function replicate(action) {
     await replicateToWorkers(state, action);
     if (action.type === "attachSegments") {
@@ -19322,6 +20257,9 @@ function createWorkerOrchestrator(config, executor, promoter, indexRegistry, cal
     replicateToWorkers: replicate,
     awaitReplication: (indexName) => awaitReplicationIdle(state, indexName),
     awaitCompactions: () => awaitCompactions(state),
+    openIndex: (indexName) => resyncIndex(indexName, true),
+    closeIndex,
+    isIndexBusy: (indexName) => state.promotionInProgress || state.replicationQueues.has(indexName) || state.compactionsInFlight.has(indexName),
     buildSegments: (requests) => buildSegments(state, requests),
     segmentBuildConcurrency: (indexName) => segmentBuildConcurrency(state, indexName),
     searchViaWorker: (indexName, params, globalStats, partitionIds) => searchViaWorker(state, indexName, params, globalStats, partitionIds),
@@ -19333,6 +20271,11 @@ function createWorkerOrchestrator(config, executor, promoter, indexRegistry, cal
   };
 }
 
+// src/engine/vector-fields.ts
+function getVectorFieldPaths(schema) {
+  return new Set(extractVectorFieldsFromSchema(schema).keys());
+}
+
 // src/engine/watermark.ts
 function createWatermarkNotifier(deps) {
   const latchedCapacity = /* @__PURE__ */ new Map();
@@ -19368,10 +20311,7 @@ function createWatermarkNotifier(deps) {
 }
 
 // src/engine/core.ts
-function getVectorFieldPaths(schema) {
-  return new Set(extractVectorFieldsFromSchema(schema).keys());
-}
-function createEngineCore(config) {
+function createEngineCore(config, hooks) {
   const executor = createDirectExecutor();
   const promoter = createExecutionPromoter({
     perIndexThreshold: config?.workers?.promotionThreshold,
@@ -19403,6 +20343,9 @@ function createEngineCore(config) {
       if (handlers) {
         for (const handler of handlers) handler({ workerCount, reason });
       }
+      void Promise.resolve(pluginRegistry.runHook("onWorkerPromote", { workerCount, reason })).catch((err) => {
+        console.warn("onWorkerPromote plugin hook failed:", err instanceof Error ? err.message : String(err));
+      });
     },
     onPromotionFailure(reason, error, retryable) {
       const handlers = eventHandlers.get("workerPromoteFailure");
@@ -19411,6 +20354,14 @@ function createEngineCore(config) {
         return;
       }
       for (const handler of handlers) handler({ reason, error, retryable });
+    },
+    onWorkerCrash(workerId, indexNames, error) {
+      const handlers = eventHandlers.get("workerCrash");
+      if (!handlers || handlers.size === 0) {
+        console.warn(`Worker ${workerId} crashed:`, error);
+        return;
+      }
+      for (const handler of handlers) handler({ workerId, indexNames, error });
     }
   });
   const rebalancer = createRebalancer();
@@ -19444,8 +20395,12 @@ function createEngineCore(config) {
     }
     return manager;
   }
-  async function createIndexFromMetadata(metadata) {
-    if (indexRegistry.has(metadata.indexName)) {
+  async function createIndexFromMetadata(metadata, loadData) {
+    const existing = indexRegistry.get(metadata.indexName);
+    if (existing !== void 0) {
+      if (loadData && executor.getManager(metadata.indexName) === void 0) {
+        executor.createIndex(metadata.indexName, existing.config, existing.language);
+      }
       return;
     }
     const indexConfig = reconstructSchemaFromMetadata(metadata);
@@ -19474,7 +20429,7 @@ function createEngineCore(config) {
       }
     }
     try {
-      executor.createIndex(metadata.indexName, indexConfig, language);
+      if (loadData) executor.createIndex(metadata.indexName, indexConfig, language);
     } catch (err) {
       if (err instanceof NarsilError && err.code === ErrorCodes.CONFIG_INVALID) {
         throw new NarsilError(err.code, `Recovery of index "${metadata.indexName}" failed: ${err.message}`, {
@@ -19492,8 +20447,12 @@ function createEngineCore(config) {
       embeddingAdapterName: adapterName,
       vectorFieldPaths: getVectorFieldPaths(indexConfig.schema),
       indexUuid: metadata.indexUuid ?? null,
-      heldPartitions: metadata.heldPartitions ?? null
+      heldPartitions: metadata.heldPartitions ?? null,
+      documentCount: metadata.documentCount ?? 0,
+      partitionCount: metadata.partitionCount
     });
+    if (loadData) await indexState.registerOpen(metadata.indexName);
+    else indexState.registerClosed(metadata.indexName);
     if (metadata.analysisRevision !== language.revision) {
       analysisRebuild.markStale({
         indexName: metadata.indexName,
@@ -19504,9 +20463,12 @@ function createEngineCore(config) {
     }
   }
   const durabilityTier = config !== void 0 ? resolveDurabilityTier(config) : null;
+  if (config?.lifecycle !== void 0 && durabilityTier === null) {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "Index lifecycle settings require durability");
+  }
   let invalidation = null;
   const durability = createDurabilityFromTier(durabilityTier, {
-    requireManager,
+    getManager: (indexName) => executor.getManager(indexName),
     indexRegistry,
     createIndexFromMetadata,
     emitFatalError(error) {
@@ -19515,7 +20477,13 @@ function createEngineCore(config) {
         for (const handler of handlers) handler({ error });
       }
     },
-    publishCheckpointedPartitions: (indexName, partitions) => invalidation?.publishPartitions(indexName, partitions) ?? Promise.resolve()
+    publishCheckpointedPartitions: (indexName, partitions) => invalidation?.publishPartitions(indexName, partitions) ?? Promise.resolve(),
+    recordCheckpoint(indexName, documentCount, partitionCount) {
+      const entry = indexRegistry.get(indexName);
+      if (entry === void 0) return;
+      entry.documentCount = documentCount;
+      entry.partitionCount = partitionCount;
+    }
   });
   invalidation = createInvalidationFromConfig(config, durabilityTier?.kind ?? null, {
     getManager: (indexName) => executor.getManager(indexName) ?? void 0,
@@ -19561,6 +20529,18 @@ function createEngineCore(config) {
     resyncIndex: (indexName, wasPromoted) => orchestrator.resyncIndex(indexName, wasPromoted),
     durabilityManager: durability?.manager ?? null
   });
+  const indexState = wireIndexState({
+    config: config?.lifecycle,
+    durability,
+    executor,
+    orchestrator,
+    analysisRebuild,
+    indexRegistry,
+    rebalancingIndexes,
+    requireManager,
+    onClose: hooks?.onIndexClose,
+    onOpen: hooks?.onIndexOpen
+  });
   const mutationCtx = {
     executor,
     pluginRegistry,
@@ -19614,6 +20594,7 @@ function createEngineCore(config) {
     bufferIfRebalancing,
     watermarkNotifier,
     analysisRebuild,
+    indexState,
     mutationCtx,
     rebalanceCtx
   };
@@ -19773,8 +20754,11 @@ async function createEngineIndex(core, config, name, indexConfig, indexUuid) {
     embeddingAdapterName,
     vectorFieldPaths: getVectorFieldPaths(indexConfig.schema),
     indexUuid: null,
-    heldPartitions: null
+    heldPartitions: null,
+    documentCount: 0,
+    partitionCount: indexConfig.partitions?.maxPartitions ?? 1
   });
+  await core.indexState.registerOpen(name);
   if (core.durability) {
     await core.durability.manager.persistMetadata(name);
   }
@@ -19783,13 +20767,21 @@ async function createEngineIndex(core, config, name, indexConfig, indexUuid) {
 async function dropEngineIndex(core, name) {
   core.guardShutdown();
   const entry = core.requireIndex(name);
-  core.executor.dropIndex(name);
-  core.indexRegistry.delete(name);
-  core.watermarkNotifier.forget(name);
-  core.analysisRebuild.clearStale(name);
-  if (core.durability) {
-    await core.durability.manager.removeIndex(name);
-  }
+  await core.indexState.drop(name, async () => {
+    await core.orchestrator.closeIndex(name);
+    if (core.durability) {
+      try {
+        await core.durability.manager.removeIndex(name);
+      } catch (error) {
+        await core.orchestrator.openIndex(name).catch(() => void 0);
+        throw error;
+      }
+    }
+    if (core.executor.getManager(name) !== void 0) core.executor.dropIndex(name);
+    core.indexRegistry.delete(name);
+    core.watermarkNotifier.forget(name);
+    core.analysisRebuild.clearStale(name);
+  });
   await core.pluginRegistry.runHook("onIndexDrop", { indexName: name, config: entry.config });
 }
 function registerEngineEmbeddingAdapter(core, name, adapter) {
@@ -19824,6 +20816,7 @@ function registerEngineEmbeddingAdapter(core, name, adapter) {
 // src/engine/lifecycle.ts
 async function shutdownEngine(core) {
   const { executor, durability, indexRegistry, eventHandlers, orchestrator } = core;
+  core.indexState.dispose();
   for (const [name] of indexRegistry) {
     const manager = executor.getManager(name);
     if (manager) {
@@ -21370,6 +22363,15 @@ async function executeRebalance(manager, indexName, targetPartitionCount, ctx) {
         }
       }
     });
+    try {
+      await ctx.pluginRegistry.runHook("onPartitionSplit", {
+        indexName,
+        oldPartitionCount: oldCount,
+        newPartitionCount: targetPartitionCount
+      });
+    } catch (hookErr) {
+      console.warn("onPartitionSplit plugin hook failed:", hookErr instanceof Error ? hookErr.message : String(hookErr));
+    }
     await replayQueued(manager, indexName, waq, ctx);
     if (ctx.durabilityManager) {
       await ctx.durabilityManager.persistMetadata(indexName);
@@ -21584,7 +22586,7 @@ async function createSnapshot(manager, entry) {
   const config = entry.config;
   const bm25 = config.bm25;
   const { encode: encode14 } = await import('@msgpack/msgpack');
-  return encode14({
+  const payload = encode14({
     version: 2,
     schema: config.schema,
     language: entry.language.name,
@@ -21614,15 +22616,17 @@ async function createSnapshot(manager, entry) {
     partitions: partitionBuffers,
     vectorIndexes: vectorPayloads
   });
+  return packIndexSnapshotEnvelope(payload);
 }
 async function restoreFromSnapshot(indexName, data, deps) {
   if (!(data instanceof Uint8Array)) {
     throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Snapshot data must be a Uint8Array");
   }
+  const payloadBytes = hasNrslMagic(data) ? await unpackIndexSnapshotEnvelope(data) : data;
   const { decode: decode14 } = await import('@msgpack/msgpack');
   let decoded;
   try {
-    decoded = decode14(data);
+    decoded = decode14(payloadBytes);
   } catch (err) {
     throw new NarsilError(
       ErrorCodes.DOC_VALIDATION_FAILED,
@@ -21704,8 +22708,12 @@ async function restoreFromSnapshot(indexName, data, deps) {
     embeddingAdapterName: adapterName,
     vectorFieldPaths: vectorFieldPaths2,
     indexUuid: null,
-    heldPartitions: null
+    heldPartitions: null,
+    documentCount: 0,
+    partitionCount: envelope.partitions.length
   });
+  await deps.indexState.registerOpen(indexName);
+  const release = await deps.indexState.acquire(indexName, false);
   try {
     const manager = deps.requireManager(indexName);
     while (manager.partitionCount < envelope.partitions.length) {
@@ -21725,26 +22733,36 @@ async function restoreFromSnapshot(indexName, data, deps) {
         }
       }
     }
+    const entry = deps.indexRegistry.get(indexName);
+    if (entry !== void 0) {
+      entry.documentCount = manager.countDocuments();
+      entry.partitionCount = manager.partitionCount;
+    }
+    if (deps.durability) {
+      for (let partitionId = 0; partitionId < manager.partitionCount; partitionId++) {
+        for (const docId of manager.getPartition(partitionId).docIds()) {
+          const document = manager.get(docId);
+          if (document !== void 0) {
+            await deps.durability.recordInsertOrUpdate(indexName, docId, document, noopApply2);
+          }
+        }
+      }
+      await deps.durability.manager.persistMetadata(indexName);
+      await deps.durability.manager.checkpoint(indexName);
+    }
   } catch (err) {
     try {
       deps.executor.dropIndex(indexName);
-      deps.indexRegistry.delete(indexName);
     } catch (_) {
     }
-    throw err;
-  }
-  if (deps.durability) {
-    const manager = deps.requireManager(indexName);
-    for (let partitionId = 0; partitionId < manager.partitionCount; partitionId++) {
-      for (const docId of manager.getPartition(partitionId).docIds()) {
-        const document = manager.get(docId);
-        if (document !== void 0) {
-          await deps.durability.recordInsertOrUpdate(indexName, docId, document, noopApply2);
-        }
-      }
+    deps.indexRegistry.delete(indexName);
+    deps.indexState.forget(indexName);
+    if (deps.durability) {
+      await deps.durability.manager.removeIndex(indexName).catch(() => void 0);
     }
-    await deps.durability.manager.persistMetadata(indexName);
-    await deps.durability.manager.checkpoint(indexName);
+    throw err;
+  } finally {
+    release();
   }
 }
 function noopApply2() {
@@ -21817,6 +22835,137 @@ function readProcessMemory() {
   }
 }
 
+// src/search/cursor-binding.ts
+var ABSENT_TAG = 0;
+var NULL_TAG = 1;
+var FALSE_TAG = 2;
+var TRUE_TAG = 3;
+var NUMBER_TAG = 4;
+var STRING_TAG = 5;
+var LIST_TAG = 6;
+var MAP_TAG = 7;
+var encoder4 = new TextEncoder();
+function ensureCapacity2(stream, extra) {
+  if (stream.length + extra <= stream.bytes.length) return;
+  const grown = new Uint8Array(Math.max(stream.bytes.length * 2, stream.length + extra));
+  grown.set(stream.bytes.subarray(0, stream.length));
+  stream.bytes = grown;
+}
+function writeByte(stream, value) {
+  ensureCapacity2(stream, 1);
+  stream.bytes[stream.length] = value;
+  stream.length += 1;
+}
+function writeUint32(stream, value) {
+  ensureCapacity2(stream, 4);
+  stream.bytes[stream.length] = value >>> 24 & 255;
+  stream.bytes[stream.length + 1] = value >>> 16 & 255;
+  stream.bytes[stream.length + 2] = value >>> 8 & 255;
+  stream.bytes[stream.length + 3] = value & 255;
+  stream.length += 4;
+}
+var numberBytes = new DataView(new ArrayBuffer(8));
+function writeNumber(stream, value) {
+  numberBytes.setFloat64(0, value, false);
+  ensureCapacity2(stream, 8);
+  for (let i = 0; i < 8; i++) {
+    stream.bytes[stream.length + i] = numberBytes.getUint8(i);
+  }
+  stream.length += 8;
+}
+function writeString(stream, value) {
+  const encoded = encoder4.encode(value);
+  writeUint32(stream, encoded.length);
+  ensureCapacity2(stream, encoded.length);
+  stream.bytes.set(encoded, stream.length);
+  stream.length += encoded.length;
+}
+function writeValue(stream, value) {
+  if (value === void 0) {
+    writeByte(stream, ABSENT_TAG);
+    return;
+  }
+  if (value === null) {
+    writeByte(stream, NULL_TAG);
+    return;
+  }
+  if (typeof value === "boolean") {
+    writeByte(stream, value ? TRUE_TAG : FALSE_TAG);
+    return;
+  }
+  if (typeof value === "number") {
+    writeByte(stream, NUMBER_TAG);
+    writeNumber(stream, value);
+    return;
+  }
+  if (typeof value === "string") {
+    writeByte(stream, STRING_TAG);
+    writeString(stream, value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    writeByte(stream, LIST_TAG);
+    writeUint32(stream, value.length);
+    for (const member of value) {
+      writeValue(stream, member ?? null);
+    }
+    return;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort(compareCodePoints);
+  writeByte(stream, MAP_TAG);
+  writeUint32(stream, keys.length);
+  for (const key of keys) {
+    writeByte(stream, STRING_TAG);
+    writeString(stream, key);
+    writeValue(stream, record[key] ?? null);
+  }
+}
+function boundVectorOf(vector) {
+  if (vector === void 0) return void 0;
+  const bound = { ...vector };
+  if (vector.value !== void 0) {
+    bound.value = Array.from(vector.value, Math.fround);
+  }
+  if (vector.text !== void 0) {
+    delete bound.value;
+  }
+  return bound;
+}
+var FILTERS_SLOT = 2;
+var BOUND_SLOT_COUNT = 15;
+function bindingOf(values) {
+  const stream = { bytes: new Uint8Array(256), length: 0 };
+  for (const value of values) {
+    writeValue(stream, value);
+  }
+  return fnv1aBytes(stream.bytes.subarray(0, stream.length)).toString(16).padStart(8, "0");
+}
+function queryBindingOf(params) {
+  return bindingOf([
+    params.term,
+    params.fields,
+    params.filters,
+    params.boost,
+    params.minScore,
+    params.termMatch,
+    params.tolerance,
+    params.prefixLength,
+    params.prefix,
+    params.exact,
+    params.pinned,
+    params.mode,
+    params.hybrid,
+    boundVectorOf(params.vector),
+    params.scoring ?? "local"
+  ]);
+}
+function listBindingOf(filters) {
+  const values = new Array(BOUND_SLOT_COUNT).fill(void 0);
+  values[FILTERS_SLOT] = filters;
+  return bindingOf(values);
+}
+
 // src/engine/list-documents/index.ts
 function clampListLimit(limit) {
   const clamped = Math.max(1, clampLimit(limit));
@@ -21851,7 +23000,7 @@ function collectCandidates(partition, anchor, matches, wanted, out) {
     taken++;
   }
 }
-function pageInIdOrder(partitions, cursor, filtered, limit) {
+function pageInIdOrder(partitions, cursor, filtered, limit, binding) {
   const anchor = cursor === null ? null : cursor.anchor;
   const candidates = [];
   for (let index = 0; index < partitions.length; index++) {
@@ -21866,10 +23015,10 @@ function pageInIdOrder(partitions, cursor, filtered, limit) {
   candidates.sort(compareCodePoints);
   const hasMore = candidates.length > limit;
   const ids = hasMore ? candidates.slice(0, limit) : candidates;
-  const nextCursor = hasMore && ids.length > 0 ? { anchor: ids[ids.length - 1], score: null, sortKey: null, sortSignature: null } : null;
+  const nextCursor = hasMore && ids.length > 0 ? { anchor: ids[ids.length - 1], score: null, sortKey: null, sortSignature: null, binding } : null;
   return { ids, nextCursor };
 }
-function pageInSortOrder(partitions, cursor, filtered, limit, sort, signature, schema) {
+function pageInSortOrder(partitions, cursor, filtered, limit, sort, signature, schema, binding) {
   const normalized = normalizeSort(sort);
   const fields = normalized.map((entry) => entry.field);
   const directions = normalized.map((entry) => entry.direction);
@@ -21892,7 +23041,7 @@ function pageInSortOrder(partitions, cursor, filtered, limit, sort, signature, s
   const hasMore = merged.length > limit;
   const page = hasMore ? merged.slice(0, limit) : merged;
   const last = page[page.length - 1];
-  const nextCursor = hasMore && last !== void 0 ? { anchor: last.id, score: null, sortKey: last.key, sortSignature: signature } : null;
+  const nextCursor = hasMore && last !== void 0 ? { anchor: last.id, score: null, sortKey: last.key, sortSignature: signature, binding } : null;
   return { ids: page.map((entry) => entry.id), nextCursor };
 }
 function countAcrossPartitions(manager, partitionIds, partitions) {
@@ -21911,15 +23060,16 @@ function executeListDocuments(params, context) {
   const limit = clampListLimit(params.limit);
   const signature = sortSignatureOf(params.sort);
   requireSortableFields(params.sort, schema);
+  const binding = listBindingOf(params.filters);
   let cursor = null;
   if (params.cursor !== void 0) {
     cursor = decodePageCursor(params.cursor);
-    requireMatchingCursor(cursor, params.cursor, signature, false);
+    requireMatchingCursor(cursor, params.cursor, signature, false, binding);
   }
   const partitions = context.partitionIds === void 0 ? manager.getAllPartitions() : context.partitionIds.map((partitionId) => manager.partitionAt(partitionId)).filter((partition) => partition !== void 0);
   const filtered = params.filters === void 0 ? null : collectFilterMatches(partitions, params.filters, schema);
   const total = filtered === null ? countAcrossPartitions(manager, context.partitionIds, partitions) : filtered.total;
-  const page = params.sort === void 0 || signature === null ? pageInIdOrder(partitions, cursor, filtered, limit) : pageInSortOrder(partitions, cursor, filtered, limit, params.sort, signature, schema);
+  const page = params.sort === void 0 || signature === null ? pageInIdOrder(partitions, cursor, filtered, limit, binding) : pageInSortOrder(partitions, cursor, filtered, limit, params.sort, signature, schema, binding);
   const projection = resolveProjection(params.document);
   const documents = [];
   for (const docId of page.ids) {
@@ -21987,18 +23137,14 @@ function applyGrouping(hits, group, getDocument) {
     }
     const result = { values: entry.values, hits: groupHits };
     if (group.reduce) {
-      try {
-        let accumulator = group.reduce.initialValue();
-        for (const hit of groupHits) {
-          const doc = getDocument(hit.id);
-          if (doc) {
-            accumulator = group.reduce.reducer(accumulator, doc, hit.score ?? 0);
-          }
-        }
-        ;
-        result.reduced = accumulator;
-      } catch (err) {
-        result.reducerError = err instanceof Error ? err.message : String(err);
+      const folded = foldGroupReducer(
+        group.reduce,
+        groupHits.map((hit) => ({ document: getDocument(hit.id), score: hit.score ?? 0 }))
+      );
+      if (folded.reducerError !== void 0) {
+        result.reducerError = folded.reducerError;
+      } else {
+        result.reduced = folded.reduced;
       }
     }
     groups.push(result);
@@ -22011,19 +23157,49 @@ function applyGrouping(hits, group, getDocument) {
     const bId = b.hits.length > 0 ? b.hits[0].id : "";
     return compareCodePoints(aId, bId);
   });
+  if (group.limit !== void 0 && Number.isFinite(group.limit) && group.limit >= 0) {
+    const cap = Math.floor(group.limit);
+    if (groups.length > cap) {
+      groups.length = cap;
+    }
+  }
   return groups;
 }
+function foldGroupReducer(reduce, rows) {
+  try {
+    let accumulator = reduce.initialValue();
+    for (const row of rows) {
+      if (row.document !== void 0) {
+        accumulator = reduce.reducer(accumulator, row.document, row.score);
+      }
+    }
+    return { reduced: accumulator };
+  } catch (err) {
+    return { reducerError: err instanceof Error ? err.message : String(err) };
+  }
+}
 
 // src/search/pinning.ts
+function dedupePinnedEntries(pinned) {
+  const deduped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of pinned) {
+    if (seen.has(entry.docId)) continue;
+    seen.add(entry.docId);
+    deduped.push(entry);
+  }
+  return deduped;
+}
 function applyPinning(hits, pinned, resolveDoc) {
   const result = hits.slice();
-  const pinnedDocIds = new Set(pinned.map((p) => p.docId));
+  const deduped = dedupePinnedEntries(pinned);
+  const pinnedDocIds = new Set(deduped.map((entry) => entry.docId));
   for (let i = result.length - 1; i >= 0; i--) {
     if (pinnedDocIds.has(result[i].id)) {
       result.splice(i, 1);
     }
   }
-  const sorted = pinned.slice().sort((a, b) => a.position - b.position);
+  const sorted = deduped.sort((a, b) => a.position - b.position);
   for (const entry of sorted) {
     const doc = resolveDoc(entry.docId);
     if (!doc) continue;
@@ -22217,17 +23393,7 @@ function applyHighlights(hits, params, language, analysis) {
 
 // src/engine/query/shared.ts
 function partitionsFor(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;
+  return partitionsIn(manager, partitionIds);
 }
 function coverageFor(manager, partitionIds) {
   if (partitionIds === void 0) {
@@ -22321,7 +23487,7 @@ function executeSortedQueryPage(params, context, limit, offset, sortSignature) {
   let anchorId = null;
   if (params.searchAfter !== void 0) {
     const decoded = decodePageCursor(params.searchAfter);
-    requireMatchingCursor(decoded, params.searchAfter, sortSignature, true);
+    requireMatchingCursor(decoded, params.searchAfter, sortSignature, true, context.cursorBinding);
     anchorKey = decoded.sortKey;
     anchorId = decoded.anchor;
   }
@@ -22366,7 +23532,13 @@ function executeSortedQueryPage(params, context, limit, offset, sortSignature) {
   const last = page[page.length - 1];
   let cursor;
   if (hasMore && last !== void 0) {
-    cursor = encodePageCursor({ anchor: last.id, score: null, sortKey: last.key, sortSignature });
+    cursor = encodePageCursor({
+      anchor: last.id,
+      score: null,
+      sortKey: last.key,
+      sortSignature,
+      binding: context.cursorBinding
+    });
   }
   return {
     hits: page.map((entry) => ({ id: entry.id, document: void 0 })),
@@ -22652,7 +23824,7 @@ async function executeQuery(params, context) {
     if (params.group) {
       groups = applyGrouping(hits, params.group, (docId) => manager.getRef(docId));
     }
-    if (params.pinned) {
+    if (params.pinned && params.searchAfter === void 0 && context.partitionIds === void 0) {
       hits = applyPinning(hits, params.pinned, (docId) => {
         const doc = manager.getRef(docId);
         if (!doc) return void 0;
@@ -22667,7 +23839,16 @@ async function executeQuery(params, context) {
         sortKeyOf
       };
     }
-    const paged = applyPagination(hits, limit, offset, params.searchAfter, sortContext);
+    const pinnedIds = params.pinned !== void 0 && params.searchAfter === void 0 ? new Set(params.pinned.map((entry) => entry.docId)) : void 0;
+    const paged = applyPagination(
+      hits,
+      limit,
+      offset,
+      context.cursorBinding,
+      params.searchAfter,
+      sortContext,
+      pinnedIds
+    );
     paginated = paged.paginated;
     nextCursor = paged.nextCursor;
     count = fanOutResult.totalMatched;
@@ -22736,6 +23917,11 @@ async function executePreflight(params, context) {
   } else if (isHybridMode && hasGlobalVectorIndex) {
     const result = await executeHybridSearch(params, context, preflightLimit, preflightOffset);
     totalMatched = result.totalMatched;
+  } else if (countsWithoutScores(params)) {
+    totalMatched = fanOutMatchCount(manager, params, language, config.schema, {
+      searchOptions: searchOptionsFor(manager),
+      partitionIds: context.partitionIds
+    });
   } else {
     const scoring = scoringConfigFor(params, context);
     const workerResult = workerSearch ? await workerSearch(indexName, params, broadcastStatsForWorker(params, context, scoring), context.partitionIds) : null;
@@ -22864,83 +24050,107 @@ function broadcastStatsFor(core, options) {
 }
 async function runEngineQuery(core, indexName, params, options) {
   core.guardShutdown();
-  const entry = core.requireIndex(indexName);
-  const manager = core.requireManager(indexName);
-  const resolvedParams = await resolveVectorText(
-    scopedParams(params),
-    entry.embeddingAdapter,
-    core.abortController.signal,
-    entry.embeddingAdapterName
-  );
-  await core.pluginRegistry.runHook("beforeSearch", { indexName, params: resolvedParams });
-  const workerSearch = core.orchestrator.isPromoted() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
-  const result = await executeQuery(resolvedParams, {
-    manager,
-    language: entry.language,
-    config: entry.config,
-    workerSearch,
-    indexName,
-    broadcastStats: broadcastStatsFor(core),
-    partitionIds: options?.partitionIds
-  });
+  const release = await core.indexState.acquire(indexName);
   try {
-    await core.pluginRegistry.runHook("afterSearch", {
+    const entry = core.requireIndex(indexName);
+    const manager = core.requireManager(indexName);
+    const resolvedParams = await resolveVectorText(
+      scopedParams(params, options),
+      entry.embeddingAdapter,
+      core.abortController.signal,
+      entry.embeddingAdapterName
+    );
+    await core.pluginRegistry.runHook("beforeSearch", { indexName, params: resolvedParams });
+    const workerSearch = core.orchestrator.isPromoted() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
+    const result = await executeQuery(resolvedParams, {
+      manager,
+      language: entry.language,
+      config: entry.config,
+      workerSearch,
       indexName,
-      params: resolvedParams,
-      results: result
+      broadcastStats: broadcastStatsFor(core, options),
+      partitionIds: options?.partitionIds,
+      cursorBinding: queryBindingOf(params)
     });
-  } catch (err) {
-    console.warn("afterSearch plugin hook error:", err);
-  }
-  if (core.analysisRebuild.isStale(indexName)) {
-    result.analysisStale = true;
+    try {
+      await core.pluginRegistry.runHook("afterSearch", {
+        indexName,
+        params: resolvedParams,
+        results: result
+      });
+    } catch (err) {
+      console.warn("afterSearch plugin hook error:", err);
+    }
+    if (core.analysisRebuild.isStale(indexName)) {
+      result.analysisStale = true;
+    }
+    return result;
+  } finally {
+    release();
   }
-  return result;
 }
 async function runEnginePreflight(core, indexName, params, options) {
   core.guardShutdown();
-  const entry = core.requireIndex(indexName);
-  const manager = core.requireManager(indexName);
-  const resolvedParams = await resolveVectorText(
-    scopedParams(params),
-    entry.embeddingAdapter,
-    core.abortController.signal,
-    entry.embeddingAdapterName
-  );
-  const workerSearch = core.orchestrator.isPromoted() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
-  const result = await executePreflight(resolvedParams, {
-    manager,
-    language: entry.language,
-    config: entry.config,
-    workerSearch,
-    indexName,
-    broadcastStats: broadcastStatsFor(core),
-    partitionIds: options?.partitionIds
-  });
-  if (core.analysisRebuild.isStale(indexName)) {
-    result.analysisStale = true;
+  const release = await core.indexState.acquire(indexName);
+  try {
+    const entry = core.requireIndex(indexName);
+    const manager = core.requireManager(indexName);
+    const resolvedParams = await resolveVectorText(
+      scopedParams(params, options),
+      entry.embeddingAdapter,
+      core.abortController.signal,
+      entry.embeddingAdapterName
+    );
+    const workerSearch = core.orchestrator.isPromoted() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
+    const result = await executePreflight(resolvedParams, {
+      manager,
+      language: entry.language,
+      config: entry.config,
+      workerSearch,
+      indexName,
+      broadcastStats: broadcastStatsFor(core, options),
+      partitionIds: options?.partitionIds,
+      cursorBinding: queryBindingOf(params)
+    });
+    if (core.analysisRebuild.isStale(indexName)) {
+      result.analysisStale = true;
+    }
+    return result;
+  } finally {
+    release();
   }
-  return result;
 }
 async function runEngineSuggest(core, indexName, params, partitionIds) {
   core.guardShutdown();
-  const result = executeSuggest(
-    core.requireManager(indexName),
-    core.requireIndex(indexName).language,
-    params);
-  if (core.analysisRebuild.isStale(indexName)) {
-    result.analysisStale = true;
+  const release = await core.indexState.acquire(indexName);
+  try {
+    const result = executeSuggest(
+      core.requireManager(indexName),
+      core.requireIndex(indexName).language,
+      params,
+      partitionIds
+    );
+    if (core.analysisRebuild.isStale(indexName)) {
+      result.analysisStale = true;
+    }
+    return result;
+  } finally {
+    release();
   }
-  return result;
 }
 async function runEngineListDocuments(core, indexName, params, partitionIds) {
   core.guardShutdown();
-  const entry = core.requireIndex(indexName);
-  return executeListDocuments(params, {
-    manager: core.requireManager(indexName),
-    schema: entry.config.schema,
-    partitionIds
-  });
+  const release = await core.indexState.acquire(indexName);
+  try {
+    const entry = core.requireIndex(indexName);
+    return executeListDocuments(params, {
+      manager: core.requireManager(indexName),
+      schema: entry.config.schema,
+      partitionIds
+    });
+  } finally {
+    release();
+  }
 }
 
 // src/narsil/operations.ts
@@ -22960,6 +24170,16 @@ function createNarsilFromCore(core, config) {
     mutationCtx,
     rebalanceCtx
   } = core;
+  async function withOpenIndex(indexName, action) {
+    guardShutdown();
+    requireIndex(indexName);
+    const release = await core.indexState.acquire(indexName);
+    try {
+      return await action();
+    } finally {
+      release();
+    }
+  }
   const narsil = {
     createIndex(name, indexConfig) {
       return createEngineIndex(core, config, name, indexConfig);
@@ -22970,15 +24190,27 @@ function createNarsilFromCore(core, config) {
     dropIndex(name) {
       return dropEngineIndex(core, name);
     },
+    open(indexName) {
+      guardShutdown();
+      requireIndex(indexName);
+      return core.indexState.open(indexName);
+    },
+    close(indexName) {
+      guardShutdown();
+      requireIndex(indexName);
+      return core.indexState.close(indexName);
+    },
     listIndexes() {
       const infos = [];
       for (const [name, entry] of indexRegistry) {
         const manager = executor.getManager(name);
         infos.push({
           name,
-          documentCount: manager?.countDocuments() ?? 0,
-          partitionCount: manager?.partitionCount ?? 0,
+          documentCount: manager?.countDocuments() ?? entry.documentCount,
+          partitionCount: manager?.partitionCount ?? entry.partitionCount,
           language: entry.language.name,
+          state: core.indexState.stateOf(name),
+          reopenCount: core.indexState.reopenCount(name),
           ...core.analysisRebuild.isStale(name) ? { analysisStale: true } : {}
         });
       }
@@ -22989,8 +24221,8 @@ function createNarsilFromCore(core, config) {
       const entry = requireIndex(indexName);
       const manager = executor.getManager(indexName);
       return {
-        documentCount: manager?.countDocuments() ?? 0,
-        partitionCount: manager?.partitionCount ?? 0,
+        documentCount: manager?.countDocuments() ?? entry.documentCount,
+        partitionCount: manager?.partitionCount ?? entry.partitionCount,
         estimatedMemoryBytes: manager?.estimateMemoryBytes() ?? 0,
         language: entry.language.name,
         schema: entry.config.schema
@@ -23002,47 +24234,48 @@ function createNarsilFromCore(core, config) {
       return executor.getManager(indexName)?.getPartitionStats() ?? [];
     },
     insert(indexName, document, docId, options) {
-      return insertDocument(mutationCtx, indexName, document, docId, options);
+      return withOpenIndex(indexName, () => insertDocument(mutationCtx, indexName, document, docId, options));
     },
     insertBatch(indexName, documents, options) {
-      return insertDocumentBatch(mutationCtx, indexName, documents, options);
+      return withOpenIndex(indexName, () => insertDocumentBatch(mutationCtx, indexName, documents, options));
     },
     remove(indexName, docId) {
-      return removeDocument(mutationCtx, indexName, docId);
+      return withOpenIndex(indexName, () => removeDocument(mutationCtx, indexName, docId));
     },
     removeBatch(indexName, docIds) {
-      return removeDocumentBatch(mutationCtx, indexName, docIds);
+      return withOpenIndex(indexName, () => removeDocumentBatch(mutationCtx, indexName, docIds));
     },
     update(indexName, docId, document) {
-      return updateDocument(mutationCtx, indexName, docId, document);
+      return withOpenIndex(indexName, () => updateDocument(mutationCtx, indexName, docId, document));
     },
     updateBatch(indexName, updates) {
-      return updateDocumentBatch(mutationCtx, indexName, updates);
+      return withOpenIndex(indexName, () => updateDocumentBatch(mutationCtx, indexName, updates));
     },
     async get(indexName, docId) {
-      guardShutdown();
-      requireIndex(indexName);
-      return executor.execute({ type: "get", indexName, docId, requestId: docId });
+      return withOpenIndex(indexName, () => executor.execute({ type: "get", indexName, docId, requestId: docId }));
     },
     async getMultiple(indexName, docIds) {
       guardShutdown();
       requireIndex(indexName);
-      const result = /* @__PURE__ */ new Map();
-      for (const docId of docIds) {
-        const doc = await narsil.get(indexName, docId);
-        if (doc !== void 0) result.set(docId, doc);
-      }
-      return result;
+      return withOpenIndex(indexName, async () => {
+        const result = /* @__PURE__ */ new Map();
+        for (const docId of docIds) {
+          const doc = await executor.execute({
+            type: "get",
+            indexName,
+            docId,
+            requestId: docId
+          });
+          if (doc !== void 0) result.set(docId, doc);
+        }
+        return result;
+      });
     },
     async has(indexName, docId) {
-      guardShutdown();
-      requireIndex(indexName);
-      return executor.execute({ type: "has", indexName, docId, requestId: docId });
+      return withOpenIndex(indexName, () => executor.execute({ type: "has", indexName, docId, requestId: docId }));
     },
     async countDocuments(indexName) {
-      guardShutdown();
-      requireIndex(indexName);
-      return executor.execute({ type: "count", indexName, requestId: indexName });
+      return withOpenIndex(indexName, () => executor.execute({ type: "count", indexName, requestId: indexName }));
     },
     async listDocuments(indexName, params) {
       return runEngineListDocuments(core, indexName, params ?? {});
@@ -23059,15 +24292,15 @@ function createNarsilFromCore(core, config) {
     async rebuildAnalysis(indexName) {
       guardShutdown();
       requireIndex(indexName);
-      await core.analysisRebuild.rebuild(indexName);
+      await withOpenIndex(indexName, () => core.analysisRebuild.rebuild(indexName));
     },
     async snapshot(indexName) {
       guardShutdown();
-      return createSnapshot(requireManager(indexName), requireIndex(indexName));
+      return withOpenIndex(indexName, () => createSnapshot(requireManager(indexName), requireIndex(indexName)));
     },
     async restore(indexName, data) {
       guardShutdown();
-      return restoreFromSnapshot(indexName, data, {
+      await restoreFromSnapshot(indexName, data, {
         executor,
         indexRegistry,
         getVectorFieldPaths,
@@ -23077,66 +24310,74 @@ function createNarsilFromCore(core, config) {
         embeddingAdapters: core.embeddingAdapters,
         defaultEmbeddingAdapter: config?.embedding ?? null,
         markAnalysisStale: core.analysisRebuild.markStale,
-        clearAnalysisStale: core.analysisRebuild.clearStale
+        clearAnalysisStale: core.analysisRebuild.clearStale,
+        indexState: core.indexState
       });
     },
     async checkpoint(indexName) {
       guardShutdown();
       requireIndex(indexName);
-      if (durability) {
-        await durability.manager.checkpoint(indexName);
-      }
+      await withOpenIndex(indexName, async () => {
+        if (durability) await durability.manager.checkpoint(indexName);
+      });
     },
     async clear(indexName) {
       guardShutdown();
       requireIndex(indexName);
-      await executor.execute({ type: "clear", indexName, requestId: indexName });
-      await orchestrator.replicateToWorkers({ type: "clear", indexName, requestId: `replicate-clear-${indexName}` });
-      core.watermarkNotifier.forget(indexName);
+      await withOpenIndex(indexName, async () => {
+        await executor.execute({ type: "clear", indexName, requestId: indexName });
+        await orchestrator.replicateToWorkers({ type: "clear", indexName, requestId: `replicate-clear-${indexName}` });
+        core.watermarkNotifier.forget(indexName);
+      });
     },
     async rebalance(indexName, targetPartitionCount) {
       guardShutdown();
       requireIndex(indexName);
-      return executeRebalance(requireManager(indexName), indexName, targetPartitionCount, rebalanceCtx);
+      return withOpenIndex(
+        indexName,
+        () => executeRebalance(requireManager(indexName), indexName, targetPartitionCount, rebalanceCtx)
+      );
     },
     async updatePartitionConfig(indexName, partitionConfig) {
       guardShutdown();
-      const entry = requireIndex(indexName);
-      const manager = requireManager(indexName);
-      if (rebalancingIndexes.has(indexName)) {
-        throw new NarsilError(
-          ErrorCodes.PARTITION_REBALANCING_BACKPRESSURE,
-          `Index "${indexName}" is currently being rebalanced`
-        );
-      }
-      validatePartitionConfig(partitionConfig);
-      if (partitionConfig.maxPartitions !== void 0 && partitionConfig.maxPartitions < manager.partitionCount) {
-        throw new NarsilError(
-          ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
-          `maxPartitions (${partitionConfig.maxPartitions}) is less than the current partition count (${manager.partitionCount})`,
-          { maxPartitions: partitionConfig.maxPartitions, partitionCount: manager.partitionCount }
-        );
-      }
-      const currentDocCount = manager.countDocuments();
-      const newMaxDocs = partitionConfig.maxDocsPerPartition ?? entry.config.partitions?.maxDocsPerPartition;
-      if (newMaxDocs !== void 0) {
-        const newTotalCapacity = newMaxDocs * manager.partitionCount;
-        if (newTotalCapacity < currentDocCount) {
+      return withOpenIndex(indexName, async () => {
+        const entry = requireIndex(indexName);
+        const manager = requireManager(indexName);
+        if (rebalancingIndexes.has(indexName)) {
+          throw new NarsilError(
+            ErrorCodes.PARTITION_REBALANCING_BACKPRESSURE,
+            `Index "${indexName}" is currently being rebalanced`
+          );
+        }
+        validatePartitionConfig(partitionConfig);
+        if (partitionConfig.maxPartitions !== void 0 && partitionConfig.maxPartitions < manager.partitionCount) {
           throw new NarsilError(
             ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
-            `New capacity (${newTotalCapacity}) is less than current document count (${currentDocCount})`,
-            { newTotalCapacity, currentDocCount }
+            `maxPartitions (${partitionConfig.maxPartitions}) is less than the current partition count (${manager.partitionCount})`,
+            { maxPartitions: partitionConfig.maxPartitions, partitionCount: manager.partitionCount }
           );
         }
-      }
-      if (!entry.config.partitions) entry.config.partitions = {};
-      if (partitionConfig.maxDocsPerPartition !== void 0)
-        entry.config.partitions.maxDocsPerPartition = partitionConfig.maxDocsPerPartition;
-      if (partitionConfig.maxPartitions !== void 0)
-        entry.config.partitions.maxPartitions = partitionConfig.maxPartitions;
-      if (partitionConfig.watermark !== void 0) entry.config.partitions.watermark = partitionConfig.watermark;
-      if (durability) await durability.manager.persistMetadata(indexName);
-      core.watermarkNotifier.check(indexName);
+        const currentDocCount = manager.countDocuments();
+        const newMaxDocs = partitionConfig.maxDocsPerPartition ?? entry.config.partitions?.maxDocsPerPartition;
+        if (newMaxDocs !== void 0) {
+          const newTotalCapacity = newMaxDocs * manager.partitionCount;
+          if (newTotalCapacity < currentDocCount) {
+            throw new NarsilError(
+              ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
+              `New capacity (${newTotalCapacity}) is less than current document count (${currentDocCount})`,
+              { newTotalCapacity, currentDocCount }
+            );
+          }
+        }
+        if (!entry.config.partitions) entry.config.partitions = {};
+        if (partitionConfig.maxDocsPerPartition !== void 0)
+          entry.config.partitions.maxDocsPerPartition = partitionConfig.maxDocsPerPartition;
+        if (partitionConfig.maxPartitions !== void 0)
+          entry.config.partitions.maxPartitions = partitionConfig.maxPartitions;
+        if (partitionConfig.watermark !== void 0) entry.config.partitions.watermark = partitionConfig.watermark;
+        if (durability) await durability.manager.persistMetadata(indexName);
+        core.watermarkNotifier.check(indexName);
+      });
     },
     async getMemoryStats() {
       let estimatedIndexBytes = 0;
@@ -23144,22 +24385,33 @@ function createNarsilFromCore(core, config) {
         estimatedIndexBytes += executor.getManager(name)?.estimateMemoryBytes() ?? 0;
       }
       const workers = await orchestrator.getWorkerMemoryStats();
-      return { process: readProcessMemory(), estimatedIndexBytes, workers };
+      const lifecycleCounts = core.indexState.counts();
+      return {
+        process: readProcessMemory(),
+        estimatedIndexBytes,
+        openIndexCount: lifecycleCounts.open,
+        closedIndexCount: lifecycleCounts.closed,
+        reopenCount: lifecycleCounts.reopens,
+        workers
+      };
     },
     async compactVectors(indexName, fieldName) {
       guardShutdown();
       requireIndex(indexName);
-      compactVectors(requireManager(indexName), indexName, fieldName);
+      await withOpenIndex(indexName, async () => {
+        compactVectors(requireManager(indexName), indexName, fieldName);
+      });
     },
     async optimizeVectors(indexName, fieldName) {
       guardShutdown();
       requireIndex(indexName);
-      await optimizeVectors(requireManager(indexName), indexName, fieldName);
+      await withOpenIndex(indexName, () => optimizeVectors(requireManager(indexName), indexName, fieldName));
     },
     vectorMaintenanceStatus(indexName) {
       guardShutdown();
       requireIndex(indexName);
-      return getVectorMaintenanceStatus(requireManager(indexName));
+      const manager = executor.getManager(indexName);
+      return manager === void 0 ? [] : getVectorMaintenanceStatus(manager);
     },
     on(event, handler) {
       const key = event;
@@ -23192,12 +24444,12 @@ function createNarsilFromCore(core, config) {
 async function createNarsil(config) {
   const core = createEngineCore(config);
   if (core.durability) {
-    await core.durability.manager.recover();
+    await core.durability.manager.recover(config?.lifecycle !== void 0);
   }
   if (core.invalidation) {
     await core.invalidation.start();
   }
-  await core.analysisRebuild.reviewStaleIndexes();
+  if (config?.lifecycle === void 0) await core.analysisRebuild.reviewStaleIndexes();
   return createNarsilFromCore(core, config);
 }