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

package/dist/{chunk-MMSWEEZT.mjs → chunk-WASNWIEK.mjs}

@@ -1,10 +1,10 @@
 import { ReplicationMessageTypes } from './chunk-JQUL2T6I.mjs';
-import { MAX_INDEX_NAME_LENGTH } from './chunk-WU2UZEVD.mjs';
-import { getNestedValue, getLanguage, extractVectorFieldsFromSchema, createDirectExecutor, createPartitionRouter, clampRowCount, DEFAULT_PAGE_SIZE, validateSchema, validateVectorPromotion, collectQueryTermStats, createPartitionManager, createVectorIndex, flattenSchema, isTextFieldType, requireWithinResultWindow, normalizeSort, sortSignatureOf, requireSortableFields, fanOutQuery, applySorting, applyPagination, resolveProjection, tokenize, decodePageCursor, requireMatchingCursor, encodePageCursor, resolveIndexAnalysis, deserializePayloadV2, deserializePayloadV1, validateRequiredFields, mergePartitionStats, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, createPartitionIndex, fnv1a, createWorkerPool, validateDocument, validateDocumentStrict, createFrozenSegment, detectRuntime, isNodeMainThread, spawnNodeWorker, createSharedFrozenSegment, buildCompactedSegmentPayload, freezeSegmentShared, deserializeMetadata, isCompositePartition, serializeMetadata, kWayMerge } from './chunk-GRWFY2HI.mjs';
+import { MAX_INDEX_NAME_LENGTH } from './chunk-XWICBGYT.mjs';
+import { getNestedValue, getLanguage, extractVectorFieldsFromSchema, createDirectExecutor, createPartitionRouter, clampRowCount, DEFAULT_PAGE_SIZE, validateSchema, validateVectorPromotion, collectQueryTermStats, createPartitionManager, createVectorIndex, flattenSchema, isTextFieldType, fnv1aBytes, requireWithinResultWindow, normalizeSort, sortSignatureOf, requireSortableFields, fanOutQuery, applySorting, applyPagination, resolveProjection, countsWithoutScores, fanOutMatchCount, tokenize, decodePageCursor, requireMatchingCursor, encodePageCursor, resolveIndexAnalysis, deserializePayloadV2, deserializePayloadV1, mergePartitionStats, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, createPartitionIndex, fnv1a, createWorkerPool, partitionsIn, detectRuntime, isNodeMainThread, spawnNodeWorker, createSharedFrozenSegment, buildCompactedSegmentPayload, freezeSegmentShared, createFrozenSegment, deserializeMetadata, isCompositePartition, serializeMetadata, kWayMerge, validateRequiredFields, validateDocument, validateDocumentStrict } from './chunk-XNCJFU2E.mjs';
 import { crc32, crc32Init, crc32Update, crc32Final } from './chunk-KMMJMDUA.mjs';
 import { compareCodePoints, compareComparableKeys } from './chunk-BFIH7OV5.mjs';
 import { generateId, createRequestId, isValidWorkerResponse } from './chunk-WTONLDU3.mjs';
-import { ErrorCodes, NarsilError } from './chunk-GB2IIJJG.mjs';
+import { ErrorCodes, NarsilError } from './chunk-P4ELXVJQ.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 // src/partitioning/rebalancer.ts
@@ -57,7 +57,7 @@ function createRebalancer() {
         skipClone: true,
         stopWordOverride: manager.analysis.stopWords,
         customTokenizer: manager.analysis.customTokenizer,
-        collectSurfaces: manager.config.surfaceForms === true
+        collectSurfaces: manager.config.surfaceForms !== false
       };
       for (const partition of currentPartitions) {
         const docIds = [...partition.docIds()];
@@ -347,7 +347,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;
@@ -399,6 +399,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);
@@ -413,23 +430,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) {
@@ -952,6 +962,9 @@ function writeHeader(header) {
   }
   return buffer;
 }
+function hasNrslMagic(data) {
+  return data.length >= MAGIC_BYTES.length && data[0] === MAGIC_BYTES[0] && data[1] === MAGIC_BYTES[1] && data[2] === MAGIC_BYTES[2] && data[3] === MAGIC_BYTES[3];
+}
 function readHeader(data) {
   if (data.length < HEADER_SIZE) {
     throw new NarsilError(
@@ -987,6 +1000,7 @@ function readHeader(data) {
 // src/serialization/envelope.ts
 var CURRENT_ENVELOPE_VERSION = 1;
 var SNAPSHOT_ENVELOPE_VERSION = 2;
+var INDEX_SNAPSHOT_ENVELOPE_VERSION = 3;
 function parseEngineVersion(version) {
   const parts = version.split(".");
   return [parseInt(parts[0] ?? "0", 10), parseInt(parts[1] ?? "0", 10), parseInt(parts[2] ?? "0", 10)];
@@ -1131,6 +1145,19 @@ function concatEnvelopeParts(parts) {
 async function unpackEnvelopeBytes(data) {
   return unpackEnvelope(data, SNAPSHOT_ENVELOPE_VERSION);
 }
+async function packIndexSnapshotEnvelope(payloadBytes) {
+  return packEnvelope(payloadBytes, { checksum: true, envelopeFormatVersion: INDEX_SNAPSHOT_ENVELOPE_VERSION });
+}
+async function unpackIndexSnapshotEnvelope(data) {
+  const { header, payloadBytes } = await unpackEnvelope(data, INDEX_SNAPSHOT_ENVELOPE_VERSION);
+  if (header.envelopeFormatVersion !== INDEX_SNAPSHOT_ENVELOPE_VERSION) {
+    throw new NarsilError(
+      ErrorCodes.ENVELOPE_VERSION_MISMATCH,
+      `Expected an index snapshot envelope of format v${INDEX_SNAPSHOT_ENVELOPE_VERSION}, received format v${header.envelopeFormatVersion}`
+    );
+  }
+  return payloadBytes;
+}
 async function writeMetadataEnvelope(meta, options = {}) {
   const payloadBytes = serializeMetadata(meta);
   return packEnvelope(payloadBytes, options);
@@ -1818,6 +1845,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) {
@@ -3310,6 +3340,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);
@@ -3320,15 +3351,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 = {
@@ -3340,6 +3369,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] : [];
@@ -3459,9 +3489,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,
@@ -3493,9 +3523,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) {
@@ -3741,7 +3933,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;
@@ -3772,20 +3963,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;
@@ -3848,7 +4039,7 @@ function createDurabilityManager(config, hooks, directoryOverride) {
         try {
           await partition.walWriter.commit();
         } catch (err) {
-          partition.failed = toError3(err);
+          partition.failed = toError4(err);
           markFatal(partition.failed);
         }
       }
@@ -3862,7 +4053,7 @@ function createDurabilityManager(config, hooks, directoryOverride) {
       try {
         await checkpointIndex(indexName);
       } catch (err) {
-        markFatal(toError3(err));
+        markFatal(toError4(err));
       }
     }
   }
@@ -3879,7 +4070,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) {
@@ -3895,82 +4086,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;
     },
@@ -3994,7 +4149,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;
         }
@@ -4006,7 +4161,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;
         }
@@ -4016,7 +4171,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;
@@ -4046,15 +4201,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) {
@@ -4093,7 +4256,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;
@@ -4124,10 +4293,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({
@@ -4143,6 +4313,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 = [];
@@ -4152,15 +4329,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;
@@ -4175,13 +4355,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;
@@ -4190,33 +4392,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) {
@@ -4224,7 +4451,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 () => {
@@ -4240,17 +4467,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));
@@ -4274,21 +4533,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;
   }
@@ -4338,8 +4598,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);
@@ -4378,9 +4639,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) {
@@ -4393,6 +4654,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,
@@ -4411,8 +4674,399 @@ function createDurabilityFromTier(tier, wiring) {
         ...entry.config.vectorPromotion !== void 0 ? { vectorPromotion: entry.config.vectorPromotion } : {}
       };
     },
-    createIndexFromMetadata: wiring.createIndexFromMetadata,
-    onFatalError: wiring.emitFatalError
+    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;
+    }
   });
 }
 
@@ -4441,7 +5095,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) {
@@ -4454,7 +5108,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) {
@@ -4480,7 +5134,7 @@ function createInvalidationIntegration(deps) {
       }
       storeForeignStats(event.indexName, event.instanceId, event.stats);
     } catch (err) {
-      onError(toError3(err));
+      onError(toError4(err));
     }
   }
   async function publishOwnStatistics() {
@@ -4502,7 +5156,7 @@ function createInvalidationIntegration(deps) {
           }
         });
       } catch (err) {
-        onError(toError3(err));
+        onError(toError4(err));
       }
     }
   }
@@ -4521,7 +5175,7 @@ function createInvalidationIntegration(deps) {
           sourceInstanceId: instanceId
         });
       } catch (err) {
-        onError(toError3(err));
+        onError(toError4(err));
       }
     },
     broadcastStats(indexName) {
@@ -4566,7 +5220,7 @@ function createInvalidationIntegration(deps) {
       try {
         await adapter.shutdown();
       } catch (err) {
-        onError(toError3(err));
+        onError(toError4(err));
       }
     }
   };
@@ -4608,7 +5262,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) {
@@ -4946,14 +5600,34 @@ async function awaitCompactions(state) {
 var DEFAULT_BACKPRESSURE_LIMIT = 100;
 var DEFAULT_REQUEST_TIMEOUT = 3e4;
 var SHUTDOWN_TIMEOUT = 5e3;
+var CONSECUTIVE_TIMEOUTS_BEFORE_DEATH = 3;
+function errorFromEventLike(event) {
+  if (event instanceof Error) {
+    return event;
+  }
+  if (typeof event === "object" && event !== null) {
+    const detail = event;
+    if (detail.error instanceof Error) {
+      return detail.error;
+    }
+    if (typeof detail.message === "string" && detail.message.length > 0) {
+      return new Error(detail.message);
+    }
+  }
+  return new Error("The worker reported an error event carrying no detail");
+}
 function createWorkerExecutor(worker, config) {
-  const backpressureLimit = DEFAULT_BACKPRESSURE_LIMIT;
-  const requestTimeout = DEFAULT_REQUEST_TIMEOUT;
+  const backpressureLimit = config?.backpressureLimit ?? DEFAULT_BACKPRESSURE_LIMIT;
+  const requestTimeout = config?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
   const pending = /* @__PURE__ */ new Map();
+  let deathError = null;
+  let shutdownRequested = false;
+  let consecutiveTimeouts = 0;
   function processResponse(msg) {
     if (!isValidWorkerResponse(msg)) {
       return;
     }
+    consecutiveTimeouts = 0;
     const response = msg;
     const entry = pending.get(response.requestId);
     if (!entry) {
@@ -4967,15 +5641,36 @@ function createWorkerExecutor(worker, config) {
       entry.resolve(response.data);
     }
   }
+  function handleDeath(cause) {
+    if (deathError !== null) {
+      return;
+    }
+    const message = cause instanceof Error ? cause.message : String(cause);
+    deathError = new NarsilError(ErrorCodes.WORKER_CRASHED, `Worker died: ${message}`);
+    for (const [id, entry] of pending) {
+      clearTimeout(entry.timeoutId);
+      entry.reject(deathError);
+      pending.delete(id);
+    }
+    if (!shutdownRequested) {
+      config?.onDeath?.(cause instanceof Error ? cause : new Error(message));
+    }
+  }
   if (typeof worker.on === "function") {
     worker.on("message", (msg) => processResponse(msg));
+    worker.on("error", (cause) => handleDeath(cause));
+    worker.on("exit", (code) => handleDeath(new Error(`Worker exited with code ${String(code)}`)));
   } else if (typeof worker.addEventListener === "function") {
     worker.addEventListener("message", (event) => {
       const msg = event.data;
       processResponse(msg);
     });
+    worker.addEventListener("error", (event) => handleDeath(errorFromEventLike(event)));
   }
   function execute(action) {
+    if (deathError !== null) {
+      return Promise.reject(deathError);
+    }
     if (pending.size >= backpressureLimit) {
       return Promise.reject(
         new NarsilError(ErrorCodes.WORKER_BUSY, `Backpressure limit of ${backpressureLimit} pending requests reached`)
@@ -4987,6 +5682,10 @@ function createWorkerExecutor(worker, config) {
       const timeoutId = setTimeout(() => {
         pending.delete(requestId);
         reject(new NarsilError(ErrorCodes.WORKER_TIMEOUT, `Request ${requestId} timed out after ${requestTimeout}ms`));
+        consecutiveTimeouts += 1;
+        if (consecutiveTimeouts >= CONSECUTIVE_TIMEOUTS_BEFORE_DEATH) {
+          handleDeath(new Error(`no answer to ${CONSECUTIVE_TIMEOUTS_BEFORE_DEATH} consecutive requests`));
+        }
       }, requestTimeout);
       pending.set(requestId, {
         resolve,
@@ -4997,6 +5696,10 @@ function createWorkerExecutor(worker, config) {
     });
   }
   async function shutdown() {
+    shutdownRequested = true;
+    if (deathError !== null) {
+      return;
+    }
     const requestId = createRequestId();
     const shutdownAction = { type: "shutdown", requestId };
     const shutdownPromise = new Promise((resolve, reject) => {
@@ -5038,15 +5741,15 @@ async function createWorkerFactory(entryPoint) {
   const resolvedEntry = resolveEntryPoint();
   if (runtime.supportsWorkerThreads) {
     const workerThreadsModule = await import('worker_threads');
-    return function nodeFactory(_workerId) {
+    return function nodeFactory(_workerId, onDeath) {
       const instance = new workerThreadsModule.Worker(new URL(resolvedEntry));
-      return createWorkerExecutor(instance);
+      return createWorkerExecutor(instance, { onDeath });
     };
   }
   if (runtime.supportsWebWorkers) {
-    return function webFactory(_workerId) {
+    return function webFactory(_workerId, onDeath) {
       const instance = new Worker(resolvedEntry, { type: "module" });
-      return createWorkerExecutor(instance);
+      return createWorkerExecutor(instance, { onDeath });
     };
   }
   throw new NarsilError(ErrorCodes.WORKER_CRASHED, `No worker support available on runtime "${runtime.runtime}"`);
@@ -5102,7 +5805,13 @@ async function runPromotion(state, reason) {
       return;
     }
     const factory = await createWorkerFactory();
-    const pool = createWorkerPool({ count: state.config?.workers?.count, workerFactory: factory });
+    const pool = createWorkerPool({
+      count: state.config?.workers?.count,
+      workerFactory: factory,
+      onWorkerCrash(workerId, indexNames, error) {
+        state.callbacks?.onWorkerCrash?.(workerId, indexNames, error);
+      }
+    });
     for (const name of promotable) {
       pool.addIndexToAll(name);
     }
@@ -5139,7 +5848,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);
@@ -5160,7 +5869,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);
@@ -5330,6 +6039,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") {
@@ -5342,6 +6101,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),
@@ -5353,6 +6115,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();
@@ -5388,10 +6155,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,
@@ -5423,6 +6187,9 @@ function createEngineCore(config) {
       if (handlers) {
         for (const handler of handlers) handler({ workerCount, reason });
       }
+      void Promise.resolve(pluginRegistry.runHook("onWorkerPromote", { workerCount, reason })).catch((err) => {
+        console.warn("onWorkerPromote plugin hook failed:", err instanceof Error ? err.message : String(err));
+      });
     },
     onPromotionFailure(reason, error, retryable) {
       const handlers = eventHandlers.get("workerPromoteFailure");
@@ -5431,6 +6198,14 @@ function createEngineCore(config) {
         return;
       }
       for (const handler of handlers) handler({ reason, error, retryable });
+    },
+    onWorkerCrash(workerId, indexNames, error) {
+      const handlers = eventHandlers.get("workerCrash");
+      if (!handlers || handlers.size === 0) {
+        console.warn(`Worker ${workerId} crashed:`, error);
+        return;
+      }
+      for (const handler of handlers) handler({ workerId, indexNames, error });
     }
   });
   const rebalancer = createRebalancer();
@@ -5464,8 +6239,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);
@@ -5494,7 +6273,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}`, {
@@ -5512,8 +6291,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,
@@ -5524,9 +6307,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) {
@@ -5535,7 +6321,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,
@@ -5581,6 +6373,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,
@@ -5634,6 +6438,7 @@ function createEngineCore(config) {
     bufferIfRebalancing,
     watermarkNotifier,
     analysisRebuild,
+    indexState,
     mutationCtx,
     rebalanceCtx
   };
@@ -5792,8 +6597,11 @@ async function createEngineIndex(core, config, name, indexConfig, indexUuid) {
     embeddingAdapterName,
     vectorFieldPaths: getVectorFieldPaths(indexConfig.schema),
     indexUuid: 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);
   }
@@ -5802,13 +6610,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) {
@@ -5843,6 +6659,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) {
@@ -7389,6 +8206,15 @@ async function executeRebalance(manager, indexName, targetPartitionCount, ctx) {
         }
       }
     });
+    try {
+      await ctx.pluginRegistry.runHook("onPartitionSplit", {
+        indexName,
+        oldPartitionCount: oldCount,
+        newPartitionCount: targetPartitionCount
+      });
+    } catch (hookErr) {
+      console.warn("onPartitionSplit plugin hook failed:", hookErr instanceof Error ? hookErr.message : String(hookErr));
+    }
     await replayQueued(manager, indexName, waq, ctx);
     if (ctx.durabilityManager) {
       await ctx.durabilityManager.persistMetadata(indexName);
@@ -7603,7 +8429,7 @@ async function createSnapshot(manager, entry) {
   const config = entry.config;
   const bm25 = config.bm25;
   const { encode: encode9 } = await import('@msgpack/msgpack');
-  return encode9({
+  const payload = encode9({
     version: 2,
     schema: config.schema,
     language: entry.language.name,
@@ -7633,15 +8459,17 @@ async function createSnapshot(manager, entry) {
     partitions: partitionBuffers,
     vectorIndexes: vectorPayloads
   });
+  return packIndexSnapshotEnvelope(payload);
 }
 async function restoreFromSnapshot(indexName, data, deps) {
   if (!(data instanceof Uint8Array)) {
     throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Snapshot data must be a Uint8Array");
   }
+  const payloadBytes = hasNrslMagic(data) ? await unpackIndexSnapshotEnvelope(data) : data;
   const { decode: decode9 } = await import('@msgpack/msgpack');
   let decoded;
   try {
-    decoded = decode9(data);
+    decoded = decode9(payloadBytes);
   } catch (err) {
     throw new NarsilError(
       ErrorCodes.DOC_VALIDATION_FAILED,
@@ -7723,8 +8551,12 @@ async function restoreFromSnapshot(indexName, data, deps) {
     embeddingAdapterName: adapterName,
     vectorFieldPaths,
     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) {
@@ -7744,26 +8576,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() {
@@ -7836,6 +8678,137 @@ function readProcessMemory() {
   }
 }
 
+// src/search/cursor-binding.ts
+var ABSENT_TAG = 0;
+var NULL_TAG = 1;
+var FALSE_TAG = 2;
+var TRUE_TAG = 3;
+var NUMBER_TAG = 4;
+var STRING_TAG = 5;
+var LIST_TAG = 6;
+var MAP_TAG = 7;
+var encoder = new TextEncoder();
+function ensureCapacity(stream, extra) {
+  if (stream.length + extra <= stream.bytes.length) return;
+  const grown = new Uint8Array(Math.max(stream.bytes.length * 2, stream.length + extra));
+  grown.set(stream.bytes.subarray(0, stream.length));
+  stream.bytes = grown;
+}
+function writeByte(stream, value) {
+  ensureCapacity(stream, 1);
+  stream.bytes[stream.length] = value;
+  stream.length += 1;
+}
+function writeUint32(stream, value) {
+  ensureCapacity(stream, 4);
+  stream.bytes[stream.length] = value >>> 24 & 255;
+  stream.bytes[stream.length + 1] = value >>> 16 & 255;
+  stream.bytes[stream.length + 2] = value >>> 8 & 255;
+  stream.bytes[stream.length + 3] = value & 255;
+  stream.length += 4;
+}
+var numberBytes = new DataView(new ArrayBuffer(8));
+function writeNumber(stream, value) {
+  numberBytes.setFloat64(0, value, false);
+  ensureCapacity(stream, 8);
+  for (let i = 0; i < 8; i++) {
+    stream.bytes[stream.length + i] = numberBytes.getUint8(i);
+  }
+  stream.length += 8;
+}
+function writeString(stream, value) {
+  const encoded = encoder.encode(value);
+  writeUint32(stream, encoded.length);
+  ensureCapacity(stream, encoded.length);
+  stream.bytes.set(encoded, stream.length);
+  stream.length += encoded.length;
+}
+function writeValue(stream, value) {
+  if (value === void 0) {
+    writeByte(stream, ABSENT_TAG);
+    return;
+  }
+  if (value === null) {
+    writeByte(stream, NULL_TAG);
+    return;
+  }
+  if (typeof value === "boolean") {
+    writeByte(stream, value ? TRUE_TAG : FALSE_TAG);
+    return;
+  }
+  if (typeof value === "number") {
+    writeByte(stream, NUMBER_TAG);
+    writeNumber(stream, value);
+    return;
+  }
+  if (typeof value === "string") {
+    writeByte(stream, STRING_TAG);
+    writeString(stream, value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    writeByte(stream, LIST_TAG);
+    writeUint32(stream, value.length);
+    for (const member of value) {
+      writeValue(stream, member ?? null);
+    }
+    return;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort(compareCodePoints);
+  writeByte(stream, MAP_TAG);
+  writeUint32(stream, keys.length);
+  for (const key of keys) {
+    writeByte(stream, STRING_TAG);
+    writeString(stream, key);
+    writeValue(stream, record[key] ?? null);
+  }
+}
+function boundVectorOf(vector) {
+  if (vector === void 0) return void 0;
+  const bound = { ...vector };
+  if (vector.value !== void 0) {
+    bound.value = Array.from(vector.value, Math.fround);
+  }
+  if (vector.text !== void 0) {
+    delete bound.value;
+  }
+  return bound;
+}
+var FILTERS_SLOT = 2;
+var BOUND_SLOT_COUNT = 15;
+function bindingOf(values) {
+  const stream = { bytes: new Uint8Array(256), length: 0 };
+  for (const value of values) {
+    writeValue(stream, value);
+  }
+  return fnv1aBytes(stream.bytes.subarray(0, stream.length)).toString(16).padStart(8, "0");
+}
+function queryBindingOf(params) {
+  return bindingOf([
+    params.term,
+    params.fields,
+    params.filters,
+    params.boost,
+    params.minScore,
+    params.termMatch,
+    params.tolerance,
+    params.prefixLength,
+    params.prefix,
+    params.exact,
+    params.pinned,
+    params.mode,
+    params.hybrid,
+    boundVectorOf(params.vector),
+    params.scoring ?? "local"
+  ]);
+}
+function listBindingOf(filters) {
+  const values = new Array(BOUND_SLOT_COUNT).fill(void 0);
+  values[FILTERS_SLOT] = filters;
+  return bindingOf(values);
+}
+
 // src/engine/list-documents/index.ts
 function clampListLimit(limit) {
   const clamped = Math.max(1, clampLimit(limit));
@@ -7870,7 +8843,7 @@ function collectCandidates(partition, anchor, matches, wanted, out) {
     taken++;
   }
 }
-function pageInIdOrder(partitions, cursor, filtered, limit) {
+function pageInIdOrder(partitions, cursor, filtered, limit, binding) {
   const anchor = cursor === null ? null : cursor.anchor;
   const candidates = [];
   for (let index = 0; index < partitions.length; index++) {
@@ -7885,10 +8858,10 @@ function pageInIdOrder(partitions, cursor, filtered, limit) {
   candidates.sort(compareCodePoints);
   const hasMore = candidates.length > limit;
   const ids = hasMore ? candidates.slice(0, limit) : candidates;
-  const nextCursor = hasMore && ids.length > 0 ? { anchor: ids[ids.length - 1], score: null, sortKey: null, sortSignature: null } : null;
+  const nextCursor = hasMore && ids.length > 0 ? { anchor: ids[ids.length - 1], score: null, sortKey: null, sortSignature: null, binding } : null;
   return { ids, nextCursor };
 }
-function pageInSortOrder(partitions, cursor, filtered, limit, sort, signature, schema) {
+function pageInSortOrder(partitions, cursor, filtered, limit, sort, signature, schema, binding) {
   const normalized = normalizeSort(sort);
   const fields = normalized.map((entry) => entry.field);
   const directions = normalized.map((entry) => entry.direction);
@@ -7911,7 +8884,7 @@ function pageInSortOrder(partitions, cursor, filtered, limit, sort, signature, s
   const hasMore = merged.length > limit;
   const page = hasMore ? merged.slice(0, limit) : merged;
   const last = page[page.length - 1];
-  const nextCursor = hasMore && last !== void 0 ? { anchor: last.id, score: null, sortKey: last.key, sortSignature: signature } : null;
+  const nextCursor = hasMore && last !== void 0 ? { anchor: last.id, score: null, sortKey: last.key, sortSignature: signature, binding } : null;
   return { ids: page.map((entry) => entry.id), nextCursor };
 }
 function countAcrossPartitions(manager, partitionIds, partitions) {
@@ -7930,15 +8903,16 @@ function executeListDocuments(params, context) {
   const limit = clampListLimit(params.limit);
   const signature = sortSignatureOf(params.sort);
   requireSortableFields(params.sort, schema);
+  const binding = listBindingOf(params.filters);
   let cursor = null;
   if (params.cursor !== void 0) {
     cursor = decodePageCursor(params.cursor);
-    requireMatchingCursor(cursor, params.cursor, signature, false);
+    requireMatchingCursor(cursor, params.cursor, signature, false, binding);
   }
   const partitions = context.partitionIds === void 0 ? manager.getAllPartitions() : context.partitionIds.map((partitionId) => manager.partitionAt(partitionId)).filter((partition) => partition !== void 0);
   const filtered = params.filters === void 0 ? null : collectFilterMatches(partitions, params.filters, schema);
   const total = filtered === null ? countAcrossPartitions(manager, context.partitionIds, partitions) : filtered.total;
-  const page = params.sort === void 0 || signature === null ? pageInIdOrder(partitions, cursor, filtered, limit) : pageInSortOrder(partitions, cursor, filtered, limit, params.sort, signature, schema);
+  const page = params.sort === void 0 || signature === null ? pageInIdOrder(partitions, cursor, filtered, limit, binding) : pageInSortOrder(partitions, cursor, filtered, limit, params.sort, signature, schema, binding);
   const projection = resolveProjection(params.document);
   const documents = [];
   for (const docId of page.ids) {
@@ -8006,18 +8980,14 @@ function applyGrouping(hits, group, getDocument) {
     }
     const result = { values: entry.values, hits: groupHits };
     if (group.reduce) {
-      try {
-        let accumulator = group.reduce.initialValue();
-        for (const hit of groupHits) {
-          const doc = getDocument(hit.id);
-          if (doc) {
-            accumulator = group.reduce.reducer(accumulator, doc, hit.score ?? 0);
-          }
-        }
-        ;
-        result.reduced = accumulator;
-      } catch (err) {
-        result.reducerError = err instanceof Error ? err.message : String(err);
+      const folded = foldGroupReducer(
+        group.reduce,
+        groupHits.map((hit) => ({ document: getDocument(hit.id), score: hit.score ?? 0 }))
+      );
+      if (folded.reducerError !== void 0) {
+        result.reducerError = folded.reducerError;
+      } else {
+        result.reduced = folded.reduced;
       }
     }
     groups.push(result);
@@ -8030,19 +9000,49 @@ function applyGrouping(hits, group, getDocument) {
     const bId = b.hits.length > 0 ? b.hits[0].id : "";
     return compareCodePoints(aId, bId);
   });
+  if (group.limit !== void 0 && Number.isFinite(group.limit) && group.limit >= 0) {
+    const cap = Math.floor(group.limit);
+    if (groups.length > cap) {
+      groups.length = cap;
+    }
+  }
   return groups;
 }
+function foldGroupReducer(reduce, rows) {
+  try {
+    let accumulator = reduce.initialValue();
+    for (const row of rows) {
+      if (row.document !== void 0) {
+        accumulator = reduce.reducer(accumulator, row.document, row.score);
+      }
+    }
+    return { reduced: accumulator };
+  } catch (err) {
+    return { reducerError: err instanceof Error ? err.message : String(err) };
+  }
+}
 
 // src/search/pinning.ts
+function dedupePinnedEntries(pinned) {
+  const deduped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of pinned) {
+    if (seen.has(entry.docId)) continue;
+    seen.add(entry.docId);
+    deduped.push(entry);
+  }
+  return deduped;
+}
 function applyPinning(hits, pinned, resolveDoc) {
   const result = hits.slice();
-  const pinnedDocIds = new Set(pinned.map((p) => p.docId));
+  const deduped = dedupePinnedEntries(pinned);
+  const pinnedDocIds = new Set(deduped.map((entry) => entry.docId));
   for (let i = result.length - 1; i >= 0; i--) {
     if (pinnedDocIds.has(result[i].id)) {
       result.splice(i, 1);
     }
   }
-  const sorted = pinned.slice().sort((a, b) => a.position - b.position);
+  const sorted = deduped.sort((a, b) => a.position - b.position);
   for (const entry of sorted) {
     const doc = resolveDoc(entry.docId);
     if (!doc) continue;
@@ -8236,17 +9236,7 @@ function applyHighlights(hits, params, language, analysis) {
 
 // src/engine/query/shared.ts
 function partitionsFor(manager, partitionIds) {
-  if (partitionIds === void 0) {
-    return manager.getAllPartitions();
-  }
-  const partitions = [];
-  for (const partitionId of partitionIds) {
-    const partition = manager.partitionAt(partitionId);
-    if (partition !== void 0) {
-      partitions.push(partition);
-    }
-  }
-  return partitions;
+  return partitionsIn(manager, partitionIds);
 }
 function coverageFor(manager, partitionIds) {
   if (partitionIds === void 0) {
@@ -8340,7 +9330,7 @@ function executeSortedQueryPage(params, context, limit, offset, sortSignature) {
   let anchorId = null;
   if (params.searchAfter !== void 0) {
     const decoded = decodePageCursor(params.searchAfter);
-    requireMatchingCursor(decoded, params.searchAfter, sortSignature, true);
+    requireMatchingCursor(decoded, params.searchAfter, sortSignature, true, context.cursorBinding);
     anchorKey = decoded.sortKey;
     anchorId = decoded.anchor;
   }
@@ -8385,7 +9375,13 @@ function executeSortedQueryPage(params, context, limit, offset, sortSignature) {
   const last = page[page.length - 1];
   let cursor;
   if (hasMore && last !== void 0) {
-    cursor = encodePageCursor({ anchor: last.id, score: null, sortKey: last.key, sortSignature });
+    cursor = encodePageCursor({
+      anchor: last.id,
+      score: null,
+      sortKey: last.key,
+      sortSignature,
+      binding: context.cursorBinding
+    });
   }
   return {
     hits: page.map((entry) => ({ id: entry.id, document: void 0 })),
@@ -8671,7 +9667,7 @@ async function executeQuery(params, context) {
     if (params.group) {
       groups = applyGrouping(hits, params.group, (docId) => manager.getRef(docId));
     }
-    if (params.pinned) {
+    if (params.pinned && params.searchAfter === void 0 && context.partitionIds === void 0) {
       hits = applyPinning(hits, params.pinned, (docId) => {
         const doc = manager.getRef(docId);
         if (!doc) return void 0;
@@ -8686,7 +9682,16 @@ async function executeQuery(params, context) {
         sortKeyOf
       };
     }
-    const paged = applyPagination(hits, limit, offset, params.searchAfter, sortContext);
+    const pinnedIds = params.pinned !== void 0 && params.searchAfter === void 0 ? new Set(params.pinned.map((entry) => entry.docId)) : void 0;
+    const paged = applyPagination(
+      hits,
+      limit,
+      offset,
+      context.cursorBinding,
+      params.searchAfter,
+      sortContext,
+      pinnedIds
+    );
     paginated = paged.paginated;
     nextCursor = paged.nextCursor;
     count = fanOutResult.totalMatched;
@@ -8755,6 +9760,11 @@ async function executePreflight(params, context) {
   } else if (isHybridMode && hasGlobalVectorIndex) {
     const result = await executeHybridSearch(params, context, preflightLimit, preflightOffset);
     totalMatched = result.totalMatched;
+  } else if (countsWithoutScores(params)) {
+    totalMatched = fanOutMatchCount(manager, params, language, config.schema, {
+      searchOptions: searchOptionsFor(manager),
+      partitionIds: context.partitionIds
+    });
   } else {
     const scoring = scoringConfigFor(params, context);
     const workerResult = workerSearch ? await workerSearch(indexName, params, broadcastStatsForWorker(params, context, scoring), context.partitionIds) : null;
@@ -8891,105 +9901,132 @@ 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, 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,
-    broadcastStats: broadcastStatsFor(core, options),
-    partitionIds: options?.partitionIds
-  });
+  const release = await core.indexState.acquire(indexName);
   try {
-    await core.pluginRegistry.runHook("afterSearch", {
+    const entry = core.requireIndex(indexName);
+    const manager = core.requireManager(indexName);
+    const resolvedParams = await resolveVectorText(
+      scopedParams(params, options),
+      entry.embeddingAdapter,
+      core.abortController.signal,
+      entry.embeddingAdapterName
+    );
+    await core.pluginRegistry.runHook("beforeSearch", { indexName, params: resolvedParams });
+    const workerSearch = core.orchestrator.isPromoted() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
+    const result = await executeQuery(resolvedParams, {
+      manager,
+      language: entry.language,
+      config: entry.config,
+      workerSearch,
       indexName,
-      params: resolvedParams,
-      results: result
+      broadcastStats: broadcastStatsFor(core, options),
+      partitionIds: options?.partitionIds,
+      cursorBinding: queryBindingOf(params)
     });
-  } catch (err) {
-    console.warn("afterSearch plugin hook error:", err);
-  }
-  if (core.analysisRebuild.isStale(indexName)) {
-    result.analysisStale = true;
+    try {
+      await core.pluginRegistry.runHook("afterSearch", {
+        indexName,
+        params: resolvedParams,
+        results: result
+      });
+    } catch (err) {
+      console.warn("afterSearch plugin hook error:", err);
+    }
+    if (core.analysisRebuild.isStale(indexName)) {
+      result.analysisStale = true;
+    }
+    return result;
+  } finally {
+    release();
   }
-  return result;
 }
 async function runEnginePreflight(core, indexName, params, options) {
   core.guardShutdown();
-  const entry = core.requireIndex(indexName);
-  const manager = core.requireManager(indexName);
-  const resolvedParams = await resolveVectorText(
-    scopedParams(params, 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
-  });
-  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,
-    partitionIds
-  );
-  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;
 }
-function runEngineQueryStats(core, indexName, terms, partitionIds) {
+async function runEngineQueryStats(core, indexName, terms, partitionIds) {
   core.guardShutdown();
-  const entry = core.requireIndex(indexName);
-  const manager = core.requireManager(indexName);
-  const stats = collectQueryTermStats(
-    manager,
-    terms.join(" "),
-    entry.language,
-    {
-      stopWords: manager.analysis.stopWords,
-      customTokenizer: manager.analysis.customTokenizer
-    },
-    partitionIds
-  );
-  return {
-    totalDocuments: stats.totalDocuments,
-    docFrequencies: stats.docFrequencies,
-    totalFieldLengths: stats.totalFieldLengths
-  };
+  const release = await core.indexState.acquire(indexName);
+  try {
+    const entry = core.requireIndex(indexName);
+    const manager = core.requireManager(indexName);
+    const stats = collectQueryTermStats(
+      manager,
+      terms.join(" "),
+      entry.language,
+      {
+        stopWords: manager.analysis.stopWords,
+        customTokenizer: manager.analysis.customTokenizer
+      },
+      partitionIds
+    );
+    return {
+      totalDocuments: stats.totalDocuments,
+      docFrequencies: stats.docFrequencies,
+      totalFieldLengths: stats.totalFieldLengths
+    };
+  } finally {
+    release();
+  }
 }
 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
@@ -9009,6 +10046,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);
@@ -9019,15 +10066,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 } : {}
         });
       }
@@ -9038,8 +10097,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
@@ -9051,47 +10110,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 ?? {});
@@ -9108,15 +10168,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,
@@ -9126,66 +10186,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;
@@ -9193,22 +10261,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;
@@ -9241,16 +10320,16 @@ 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);
 }
 
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, VERSION, WIRE_BATCH_BUDGET, applyDeleteEntry, applyIndexEntry, chunkByBudget, clampLimit, computeEntryChecksum, createAckMessage, createDurableDirectory, createEngineCore, createEngineIndex, createEntryBatchMessage, createEntryMessage, createForwardBatchMessage, createForwardBatchResultMessage, createForwardMessage, createInsyncAddMessage, createInsyncConfirmMessage, createInsyncRemoveMessage, createNarsil, createNarsilFromCore, now, runEngineListDocuments, runEnginePreflight, runEngineQuery, runEngineQueryStats, runEngineSuggest, validateAckPayload, validateEntryBatchPayload, validateEntryPayload, validateForwardBatchPayload, validateForwardBatchResultPayload, validateInsyncConfirmPayload, validateReplicationEntry, writeSegmentedCheckpoint };
+export { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, VERSION, WIRE_BATCH_BUDGET, applyDeleteEntry, applyIndexEntry, chunkByBudget, clampLimit, computeEntryChecksum, createAckMessage, createDurableDirectory, createEngineCore, createEngineIndex, createEntryBatchMessage, createEntryMessage, createForwardBatchMessage, createForwardBatchResultMessage, createForwardMessage, createInsyncAddMessage, createInsyncConfirmMessage, createInsyncRemoveMessage, createNarsil, createNarsilFromCore, dedupePinnedEntries, foldGroupReducer, listBindingOf, now, queryBindingOf, runEngineListDocuments, runEnginePreflight, runEngineQuery, runEngineQueryStats, runEngineSuggest, validateAckPayload, validateEntryBatchPayload, validateEntryPayload, validateForwardBatchPayload, validateForwardBatchResultPayload, validateInsyncConfirmPayload, validateReplicationEntry, writeSegmentedCheckpoint };