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

package/dist/index.browser.mjs

@@ -12,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",
@@ -2488,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 };
   }
@@ -2561,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 };
   }
@@ -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);
 }
 
@@ -8441,6 +8523,9 @@ function createFrozenDocTable(idTable, lengthColumns, documents, tombstones) {
     internalIdCapacity() {
       return capacity;
     },
+    contentBytes() {
+      return documents.byteLength;
+    },
     resolver() {
       return resolver;
     }
@@ -8468,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];
     }
@@ -13115,11 +13211,7 @@ function createWorkerPool(config) {
     indexAssignment.set(indexName, slotIndex);
   }
   function removeIndex(indexName) {
-    const slotIndex = indexAssignment.get(indexName);
-    if (slotIndex === void 0) {
-      return;
-    }
-    workers.get(slotIndex)?.indexes.delete(indexName);
+    for (const slot of workers.values()) slot.indexes.delete(indexName);
     indexAssignment.delete(indexName);
   }
   function getExecutor(indexName) {
@@ -14317,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();
     }
@@ -14611,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;
@@ -14663,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);
@@ -14677,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) {
@@ -16142,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) {
@@ -17395,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);
@@ -17405,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 = {
@@ -17425,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] : [];
@@ -17544,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,
@@ -17578,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) {
@@ -17826,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;
@@ -17857,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;
@@ -17933,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);
         }
       }
@@ -17947,7 +18216,7 @@ function createDurabilityManager(config, hooks, directoryOverride) {
       try {
         await checkpointIndex(indexName);
       } catch (err) {
-        markFatal(toError3(err));
+        markFatal(toError4(err));
       }
     }
   }
@@ -17964,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) {
@@ -17980,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;
     },
@@ -18079,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;
         }
@@ -18091,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;
         }
@@ -18101,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;
@@ -18131,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) {
@@ -18178,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;
@@ -18209,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({
@@ -18228,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 = [];
@@ -18237,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;
@@ -18260,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;
@@ -18275,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) {
@@ -18309,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 () => {
@@ -18325,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));
@@ -18359,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;
   }
@@ -18423,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);
@@ -18463,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) {
@@ -18478,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,
@@ -18497,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;
@@ -18526,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) {
@@ -18539,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) {
@@ -18565,7 +19297,7 @@ function createInvalidationIntegration(deps) {
       }
       storeForeignStats(event.indexName, event.instanceId, event.stats);
     } catch (err) {
-      onError(toError3(err));
+      onError(toError4(err));
     }
   }
   async function publishOwnStatistics() {
@@ -18587,7 +19319,7 @@ function createInvalidationIntegration(deps) {
           }
         });
       } catch (err) {
-        onError(toError3(err));
+        onError(toError4(err));
       }
     }
   }
@@ -18606,7 +19338,7 @@ function createInvalidationIntegration(deps) {
           sourceInstanceId: instanceId
         });
       } catch (err) {
-        onError(toError3(err));
+        onError(toError4(err));
       }
     },
     broadcastStats(indexName) {
@@ -18651,7 +19383,7 @@ function createInvalidationIntegration(deps) {
       try {
         await adapter.shutdown();
       } catch (err) {
-        onError(toError3(err));
+        onError(toError4(err));
       }
     }
   };
@@ -18693,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) {
@@ -19272,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);
@@ -19293,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);
@@ -19463,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") {
@@ -19475,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),
@@ -19486,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();
@@ -19521,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,
@@ -19608,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);
@@ -19638,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}`, {
@@ -19656,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,
@@ -19668,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) {
@@ -19679,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,
@@ -19725,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,
@@ -19778,6 +20594,7 @@ function createEngineCore(config) {
     bufferIfRebalancing,
     watermarkNotifier,
     analysisRebuild,
+    indexState,
     mutationCtx,
     rebalanceCtx
   };
@@ -19937,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);
   }
@@ -19947,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) {
@@ -19988,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) {
@@ -21879,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) {
@@ -21900,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() {
@@ -23207,85 +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,
-    cursorBinding: queryBindingOf(params)
-  });
+  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,
-    cursorBinding: queryBindingOf(params)
-  });
-  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
@@ -23305,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);
@@ -23315,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 } : {}
         });
       }
@@ -23334,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
@@ -23347,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 ?? {});
@@ -23404,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,
@@ -23422,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;
@@ -23489,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;
@@ -23537,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);
 }