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

package/dist/distribution.mjs

@@ -1,7 +1,7 @@
-import { createEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, now, listBindingOf, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, queryBindingOf, foldGroupReducer, clampLimit, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, MAX_SUGGEST_SCATTER_LIMIT, chunkByBudget, WIRE_BATCH_BUDGET, dedupePinnedEntries, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, createEntryMessage, computeEntryChecksum, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-KEDL6FFZ.mjs';
+import { createEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, now, listBindingOf, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, queryBindingOf, foldGroupReducer, clampLimit, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, MAX_SUGGEST_SCATTER_LIMIT, chunkByBudget, WIRE_BATCH_BUDGET, computeEntryChecksum, dedupePinnedEntries, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, createEntryMessage, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-WASNWIEK.mjs';
 import { ReplicationMessageTypes, TransportErrorCodes, ClusterMessageTypes, QueryMessageTypes, TransportError, MAX_MESSAGE_SIZE_BYTES } from './chunk-JQUL2T6I.mjs';
-import { validateIndexName, indexConfigKey, putIndexMetadata, getIndexMetadata, MAX_PARTITION_COUNT, MAX_INDEX_NAME_LENGTH } from './chunk-O4Q5JYNK.mjs';
-import { deserializePayloadV2, createPartitionIndex, resolveProjection, clampRowCount, sortSignatureOf, requireMatchingCursor, decodePageCursor, normalizeSort, encodePageCursor, applyProjection, readSortValues, getLanguage, DEFAULT_PAGE_SIZE, requireWithinResultWindow, fnv1a, FILTER_EXPRESSION_KEYS, MAX_CURSOR_LENGTH, mergePartitionStats, RESULT_WINDOW, FIELD_FILTER_OPERATORS, MAX_NESTING_DEPTH } from './chunk-YGQMKTKG.mjs';
+import { validateIndexName, indexConfigKey, putIndexMetadata, getIndexMetadata, MAX_PARTITION_COUNT, MAX_INDEX_NAME_LENGTH } from './chunk-XWICBGYT.mjs';
+import { deserializePayloadV2, createPartitionIndex, resolveProjection, clampRowCount, sortSignatureOf, requireMatchingCursor, decodePageCursor, normalizeSort, encodePageCursor, applyProjection, readSortValues, getLanguage, DEFAULT_PAGE_SIZE, requireWithinResultWindow, fnv1a, FILTER_EXPRESSION_KEYS, MAX_CURSOR_LENGTH, mergePartitionStats, RESULT_WINDOW, FIELD_FILTER_OPERATORS, MAX_NESTING_DEPTH } from './chunk-XNCJFU2E.mjs';
 import './chunk-TGP5M5R7.mjs';
 import './chunk-OBXS7OZM.mjs';
 import './chunk-WDL632CN.mjs';
@@ -9,7 +9,7 @@ import { crc32 } from './chunk-KMMJMDUA.mjs';
 import './chunk-U2BKYEC7.mjs';
 import { compareCodePoints, toComparableSortValue, compareComparableKeys, compareSortValues } from './chunk-BFIH7OV5.mjs';
 import { generateId } from './chunk-WTONLDU3.mjs';
-import { ErrorCodes, NarsilError, describeError } from './chunk-TLRUUMVE.mjs';
+import { ErrorCodes, NarsilError, describeError } from './chunk-P4ELXVJQ.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 // src/distribution/cluster/controller/types.ts
@@ -4618,7 +4618,7 @@ function batchBytes(entries) {
 function replicaHasFallenOutOfRetention(log, cursor) {
   const oldest = log.oldestSeqNo;
   if (oldest === void 0) {
-    return false;
+    return cursor.appliedSeqNo < log.localLogEnd;
   }
   return cursor.appliedSeqNo + 1 < oldest;
 }
@@ -4844,473 +4844,766 @@ async function writeHeldPartitions(core, indexName, next, indexesBehindOnDisk) {
   indexesBehindOnDisk.delete(indexName);
 }
 
-// src/distribution/cluster-node/local-engine.ts
-async function createClusterLocalEngine(config) {
-  const core = createEngineCore(config);
-  if (core.durability !== null) {
-    await core.durability.manager.recover();
-  }
-  if (core.invalidation !== null) {
-    await core.invalidation.start();
-  }
-  await core.analysisRebuild.reviewStaleIndexes();
-  const engine = createNarsilFromCore(core, config);
-  const heldPartitions = createHeldPartitionRecord(core);
-  return Object.assign(engine, {
-    createIndexWithUuid: (name, indexConfig, indexUuid) => createEngineIndex(core, config, name, indexConfig, indexUuid),
-    indexUuidOf: (indexName) => core.indexRegistry.get(indexName)?.indexUuid,
-    stampIndexUuid: (indexName, indexUuid) => stampIndexUuid(core, indexName, indexUuid),
-    highestPersistedSeqNoOf: (indexName, partitionId) => core.durability?.manager.highestPersistedSeqNo(indexName, partitionId) ?? 0,
-    heldPartitionsOf: (indexName) => heldPartitions.held(indexName),
-    recordHeldPartition: (indexName, partitionId) => heldPartitions.record(indexName, partitionId),
-    forgetHeldPartition: (indexName, partitionId) => heldPartitions.forget(indexName, partitionId),
-    applyReplicationEntry: (entry) => applyReplicationEntry(core, entry),
-    serializeReplicationPartition: (indexName, partitionId) => serializeReplicationPartition(core, indexName, partitionId),
-    restoreReplicationPartition: (indexName, partitionId, bytes, schema, partitionCount) => restoreReplicationPartition(core, engine, indexName, partitionId, bytes, schema, partitionCount),
-    queryPartitions: (indexName, params, partitionIds, globalStats) => runEngineQuery(core, indexName, params, { partitionIds, globalStats }),
-    preflightPartitions: (indexName, params, partitionIds) => runEnginePreflight(core, indexName, params, { partitionIds }),
-    suggestPartitions: (indexName, params, partitionIds) => runEngineSuggest(core, indexName, params, partitionIds),
-    listPartitions: (indexName, params, partitionIds) => runEngineListDocuments(core, indexName, params, partitionIds),
-    collectQueryStats: (indexName, terms, partitionIds) => runEngineQueryStats(core, indexName, terms, partitionIds)
-  });
-}
-async function stampIndexUuid(core, indexName, indexUuid) {
-  const entry = core.indexRegistry.get(indexName);
-  if (entry === void 0 || entry.indexUuid === indexUuid) {
-    return;
-  }
-  core.indexRegistry.set(indexName, { ...entry, indexUuid });
-  if (core.durability !== null) {
-    await core.durability.manager.persistMetadata(indexName);
-  }
-}
-async function serializeReplicationPartition(core, indexName, partitionId) {
-  core.guardShutdown();
-  return core.requireManager(indexName).serializePartitionToBytes(partitionId);
-}
-async function restoreReplicationPartition(core, engine, indexName, partitionId, bytes, schema, partitionCount) {
-  core.guardShutdown();
-  validatePartitionRestoreTarget(indexName, partitionId, partitionCount);
-  let partition;
-  try {
-    partition = deserializePayloadV2(bytes);
-  } catch (err) {
-    const cause = err instanceof Error ? err.message : String(err);
-    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, `partition snapshot decode failed: ${cause}`, {
-      indexName,
-      partitionId,
-      cause
-    });
-  }
-  validatePartitionSnapshotPayload(indexName, partitionId, partitionCount, schema, partition);
-  const trackPositions = core.indexRegistry.get(indexName)?.config.trackPositions ?? true;
-  createPartitionIndex(partitionId, trackPositions).deserialize(partition, schema);
-  const restoreIndex = await ensureReplicationIndex(core, engine, indexName, schema, partition.language, partitionCount);
-  if (restoreIndex.created) {
-    await core.orchestrator.replicateToWorkers({
-      type: "createIndex",
-      indexName,
-      config: restoreIndex.config,
-      requestId: `replicate-partition-index-${indexName}`
-    });
-  }
-  const manager = core.requireManager(indexName);
-  manager.deserializePartition(partitionId, partition);
-  await core.orchestrator.replicateToWorkers({
-    type: "deserialize",
-    indexName,
-    partitionId,
-    data: partition,
-    requestId: `replicate-partition-restore-${indexName}-${partitionId}`
-  });
-}
-function validatePartitionRestoreTarget(indexName, partitionId, partitionCount) {
-  if (!Number.isInteger(partitionId) || partitionId < 0) {
-    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partitionId must be a non-negative integer", {
-      indexName,
-      partitionId
-    });
-  }
-  if (!Number.isInteger(partitionCount) || partitionCount <= 0 || partitionCount > MAX_PARTITION_COUNT) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED,
-      `partitionCount must be an integer between 1 and ${MAX_PARTITION_COUNT}`,
-      { indexName, partitionCount }
-    );
-  }
-  if (partitionId >= partitionCount) {
-    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partitionId is outside partitionCount", {
-      indexName,
-      partitionId,
-      partitionCount
-    });
-  }
+// src/distribution/replication/types.ts
+var DEFAULT_LOG_RETENTION_BYTES = 268435456;
+
+// src/distribution/replication/log.ts
+var ENTRY_FIXED_OVERHEAD_BYTES2 = 40;
+function estimateEntrySize(entry) {
+  return ENTRY_FIXED_OVERHEAD_BYTES2 + entry.indexName.length + entry.documentId.length + (entry.document?.byteLength ?? 0);
 }
-function validatePartitionSnapshotPayload(indexName, partitionId, partitionCount, schema, partition) {
-  if (partition.indexName !== indexName) {
-    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot indexName mismatch", {
-      expectedIndexName: indexName,
-      receivedIndexName: partition.indexName
-    });
-  }
-  if (partition.partitionId !== partitionId) {
-    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot partitionId mismatch", {
-      indexName,
-      expectedPartitionId: partitionId,
-      receivedPartitionId: partition.partitionId
-    });
-  }
-  if (partition.totalPartitions !== partitionCount) {
-    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot partition count mismatch", {
-      indexName,
-      partitionId,
-      expectedPartitionCount: partitionCount,
-      receivedPartitionCount: partition.totalPartitions
-    });
-  }
-  const expectedSchema = flattenSchema(schema);
-  for (const [field, expectedType] of Object.entries(expectedSchema)) {
-    if (partition.schema[field] !== expectedType) {
-      throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot schema mismatch", {
-        indexName,
-        partitionId,
-        field,
-        expected: expectedType,
-        received: partition.schema[field] ?? "(absent)"
-      });
-    }
+var computeChecksum = computeEntryChecksum;
+function createReplicationLog(partitionId, config) {
+  const retentionBytes = config?.logRetentionBytes ?? DEFAULT_LOG_RETENTION_BYTES;
+  let nextSeqNo = config?.startSeqNo ?? 1;
+  let localLogEnd = nextSeqNo - 1;
+  let localLogEndPrimaryTerm = config?.lastPrimaryTerm ?? 0;
+  let commitPoint = nextSeqNo - 1;
+  let entries = [];
+  let headIndex = 0;
+  let totalSizeBytes = 0;
+  function liveCount() {
+    return entries.length - headIndex;
   }
-  for (const field of Object.keys(partition.schema)) {
-    if (!(field in expectedSchema)) {
-      throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot schema contains extra field", {
-        indexName,
-        partitionId,
-        field
-      });
+  function compact() {
+    if (headIndex > 0) {
+      entries = entries.slice(headIndex);
+      headIndex = 0;
     }
   }
-}
-async function ensureReplicationIndex(core, engine, indexName, schema, languageName, partitionCount) {
-  const language = getLanguage(languageName);
-  const existing = core.indexRegistry.get(indexName);
-  let created = false;
-  if (existing === void 0) {
-    const indexConfig = {
-      schema,
-      language: language.name,
-      partitions: { maxPartitions: partitionCount }
-    };
-    try {
-      await engine.createIndex(indexName, indexConfig);
-      created = true;
-    } catch (err) {
-      if (!(err instanceof NarsilError) || err.code !== ErrorCodes.INDEX_ALREADY_EXISTS) {
-        throw err;
+  function findIndexBySeqNo(seqNo) {
+    let low = headIndex;
+    let high = entries.length - 1;
+    while (low <= high) {
+      const mid = low + high >>> 1;
+      const midSeqNo = entries[mid].seqNo;
+      if (midSeqNo < seqNo) {
+        low = mid + 1;
+      } else if (midSeqNo > seqNo) {
+        high = mid - 1;
+      } else {
+        return mid;
       }
     }
+    return low;
   }
-  const entry = core.requireIndex(indexName);
-  if (entry.language.name !== language.name) {
-    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot language mismatch", {
-      indexName,
-      expectedLanguage: entry.language.name,
-      receivedLanguage: language.name
-    });
-  }
-  validateExistingSchema(indexName, schema, entry.config.schema);
-  const manager = core.requireManager(indexName);
-  if (manager.partitionCount > partitionCount) {
-    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "local index has more partitions than allocation", {
-      indexName,
-      localPartitionCount: manager.partitionCount,
-      allocationPartitionCount: partitionCount
-    });
-  }
-  if (entry.config.partitions === void 0) {
-    entry.config.partitions = { maxPartitions: partitionCount };
-  } else if ((entry.config.partitions.maxPartitions ?? manager.partitionCount) < partitionCount) {
-    entry.config.partitions.maxPartitions = partitionCount;
+  function evictOldEntries() {
+    while (liveCount() > 0 && totalSizeBytes > retentionBytes) {
+      totalSizeBytes -= estimateEntrySize(entries[headIndex]);
+      entries[headIndex] = null;
+      headIndex += 1;
+    }
+    if (totalSizeBytes < 0) {
+      totalSizeBytes = 0;
+    }
+    if (headIndex >= 256 || headIndex > liveCount()) {
+      compact();
+    }
   }
-  while (manager.partitionCount < partitionCount) {
-    manager.addPartition();
+  function assertEntryFitsRetention(entry) {
+    const entrySize = ENTRY_FIXED_OVERHEAD_BYTES2 + entry.indexName.length + entry.documentId.length + (entry.document?.byteLength ?? 0);
+    if (entrySize > retentionBytes) {
+      throw new NarsilError(
+        ErrorCodes.REPLICATION_LOG_FULL,
+        `Replication log entry of ${entrySize} bytes exceeds the log retention limit of ${retentionBytes} bytes and cannot be buffered`,
+        { partitionId, entrySize, retentionBytes, seqNo: entry.seqNo }
+      );
+    }
   }
-  return { config: entry.config, created };
-}
-function validateExistingSchema(indexName, expected, actual) {
-  const expectedSchema = flattenSchema(expected);
-  const actualSchema = flattenSchema(actual);
-  for (const [field, expectedType] of Object.entries(expectedSchema)) {
-    if (actualSchema[field] !== expectedType) {
-      throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "local index schema mismatch", {
-        indexName,
-        field,
-        expected: expectedType,
-        received: actualSchema[field] ?? "(absent)"
-      });
+  function storeEntry(entry) {
+    entries.push(entry);
+    if (entry.seqNo >= localLogEnd) {
+      localLogEnd = entry.seqNo;
+      localLogEndPrimaryTerm = entry.primaryTerm;
     }
+    totalSizeBytes += estimateEntrySize(entry);
+    evictOldEntries();
+    return { ...entry };
   }
-  for (const field of Object.keys(actualSchema)) {
-    if (!(field in expectedSchema)) {
-      throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "local index schema contains extra field", {
-        indexName,
-        field
-      });
+  function readEntry(seqNo) {
+    if (liveCount() === 0) return void 0;
+    const idx = findIndexBySeqNo(seqNo);
+    if (idx < entries.length && entries[idx].seqNo === seqNo) {
+      return { ...entries[idx] };
     }
+    return void 0;
   }
-}
-function flattenSchema(schema) {
-  const flat = {};
-  flattenSchemaInto(schema, "", flat);
-  return flat;
-}
-function flattenSchemaInto(schema, prefix, flat) {
-  for (const [field, value] of Object.entries(schema)) {
-    const path = prefix.length === 0 ? field : `${prefix}.${field}`;
-    if (isNestedSchema(value)) {
-      flattenSchemaInto(value, path, flat);
-      continue;
-    }
-    flat[path] = value;
+  function verifyEntryChecksum(entry) {
+    const expected = computeChecksum({
+      seqNo: entry.seqNo,
+      primaryTerm: entry.primaryTerm,
+      operation: entry.operation,
+      partitionId: entry.partitionId,
+      indexName: entry.indexName,
+      documentId: entry.documentId,
+      document: entry.document
+    });
+    return expected === entry.checksum;
   }
-}
-function isNestedSchema(value) {
-  return typeof value === "object" && value !== null;
-}
-async function applyReplicationEntry(core, entry) {
-  core.guardShutdown();
-  const indexEntry = core.requireIndex(entry.indexName);
-  const manager = core.requireManager(entry.indexName);
-  const vecIndexes = manager.getVectorIndexes();
-  if (entry.operation === "INDEX") {
-    applyIndexEntry(entry, manager, indexEntry.vectorFieldPaths, vecIndexes);
-    const appliedDocument = manager.get(entry.documentId);
-    if (appliedDocument !== void 0) {
-      await core.orchestrator.replicateToWorkers({
-        type: "insert",
-        indexName: entry.indexName,
-        docId: entry.documentId,
-        document: appliedDocument,
-        requestId: `replicate-entry-insert-${entry.indexName}-${entry.partitionId}-${entry.seqNo}`
-      });
+  return {
+    append(partial) {
+      assertEntryFitsRetention(partial);
+      const seqNo = nextSeqNo;
+      nextSeqNo += 1;
+      const entryWithoutChecksum = {
+        seqNo,
+        primaryTerm: partial.primaryTerm,
+        operation: partial.operation,
+        partitionId,
+        indexName: partial.indexName,
+        documentId: partial.documentId,
+        document: partial.document
+      };
+      const checksum = computeChecksum(entryWithoutChecksum);
+      const entry = { ...entryWithoutChecksum, checksum };
+      return storeEntry(entry);
+    },
+    appendCommitted(entry) {
+      if (!Number.isSafeInteger(entry.seqNo) || entry.seqNo < 1) {
+        throw new NarsilError(
+          ErrorCodes.REPLICATION_ENTRY_INVALID,
+          `Invalid replication sequence number ${entry.seqNo}`,
+          {
+            seqNo: entry.seqNo,
+            partitionId
+          }
+        );
+      }
+      if (entry.partitionId !== partitionId) {
+        throw new NarsilError(
+          ErrorCodes.REPLICATION_ENTRY_INVALID,
+          `Replication entry partition ${entry.partitionId} does not match log partition ${partitionId}`,
+          { entryPartitionId: entry.partitionId, logPartitionId: partitionId }
+        );
+      }
+      const existing = readEntry(entry.seqNo);
+      if (existing !== void 0) {
+        if (existing.checksum !== entry.checksum) {
+          throw new NarsilError(
+            ErrorCodes.REPLICATION_ENTRY_INVALID,
+            `Conflicting replication entry at sequence number ${entry.seqNo}`,
+            { seqNo: entry.seqNo, partitionId }
+          );
+        }
+        return existing;
+      }
+      if (entry.seqNo !== nextSeqNo) {
+        throw new NarsilError(
+          ErrorCodes.REPLICATION_ENTRY_INVALID,
+          `Out-of-order replication entry ${entry.seqNo}; expected ${nextSeqNo}`,
+          { seqNo: entry.seqNo, expectedSeqNo: nextSeqNo, partitionId }
+        );
+      }
+      if (!verifyEntryChecksum(entry)) {
+        throw new NarsilError(
+          ErrorCodes.REPLICATION_ENTRY_CORRUPT,
+          `Invalid checksum for replication entry ${entry.seqNo}`,
+          { seqNo: entry.seqNo, partitionId }
+        );
+      }
+      assertEntryFitsRetention(entry);
+      nextSeqNo = entry.seqNo + 1;
+      return storeEntry({ ...entry });
+    },
+    getEntriesFrom(fromSeqNo) {
+      if (liveCount() === 0) return [];
+      const idx = findIndexBySeqNo(fromSeqNo);
+      if (idx >= entries.length) return [];
+      return entries.slice(idx).map((e) => ({ ...e }));
+    },
+    getEntry(seqNo) {
+      return readEntry(seqNo);
+    },
+    verifyChecksum(entry) {
+      return verifyEntryChecksum(entry);
+    },
+    get localLogEnd() {
+      return localLogEnd;
+    },
+    get localLogEndPrimaryTerm() {
+      return localLogEndPrimaryTerm;
+    },
+    get commitPoint() {
+      return commitPoint;
+    },
+    advanceCommitPoint(seqNo) {
+      const bounded = Math.min(seqNo, localLogEnd);
+      if (bounded > commitPoint) {
+        commitPoint = bounded;
+      }
+    },
+    get oldestSeqNo() {
+      if (liveCount() === 0) return void 0;
+      return entries[headIndex].seqNo;
+    },
+    get newestSeqNo() {
+      if (liveCount() === 0) return void 0;
+      return entries[entries.length - 1].seqNo;
+    },
+    get entryCount() {
+      return liveCount();
+    },
+    get sizeBytes() {
+      return totalSizeBytes;
+    },
+    clear() {
+      entries = [];
+      headIndex = 0;
+      totalSizeBytes = 0;
+      localLogEnd = nextSeqNo - 1;
+      commitPoint = nextSeqNo - 1;
     }
-    return;
-  }
-  applyDeleteEntry(entry, manager, vecIndexes);
-  await core.orchestrator.replicateToWorkers({
-    type: "remove",
-    indexName: entry.indexName,
-    docId: entry.documentId,
-    requestId: `replicate-entry-remove-${entry.indexName}-${entry.partitionId}-${entry.seqNo}`
-  });
+  };
 }
 
-// src/distribution/cluster-node/local-index-reconcile.ts
-async function reconcileLocalIndexes(deps) {
-  const dispositions = /* @__PURE__ */ new Map();
-  for (const index of deps.engine.listIndexes()) {
-    const disposition = await reconcileOne(deps, index.name);
-    dispositions.set(index.name, disposition);
-  }
-  return dispositions;
+// src/distribution/cluster-node/replication-logs.ts
+function replicationLogKey(indexName, partitionId) {
+  return `${indexName}:${partitionId}`;
 }
-async function adoptClusterIdentity(engine, coordinator, indexName) {
-  if (engine.indexUuidOf(indexName) !== null) {
-    return;
-  }
-  const metadata = await getIndexMetadata(coordinator, indexName);
-  if (metadata === null) {
-    return;
+function getReplicationLog(replicationLogs, indexName, partitionId, replicationConfig) {
+  const key = replicationLogKey(indexName, partitionId);
+  let log = replicationLogs.get(key);
+  if (log === void 0) {
+    log = createReplicationLog(partitionId, { logRetentionBytes: replicationConfig?.logRetentionBytes });
+    replicationLogs.set(key, log);
   }
-  await engine.stampIndexUuid(indexName, metadata.indexUuid);
+  return log;
 }
-function orphanedIndexError(nodeId, indexName) {
-  return new NarsilError(
-    ErrorCodes.INDEX_ORPHANED,
-    `Node '${nodeId}' holds a local copy of index '${indexName}' the cluster does not claim, so it answers nothing for that name. Drop it to reclaim the space`,
-    { indexName, nodeId }
+function seedReplicationLog(replicationLogs, indexName, partitionId, startSeqNo, lastPrimaryTerm = 0, replicationConfig) {
+  replicationLogs.set(
+    replicationLogKey(indexName, partitionId),
+    createReplicationLog(partitionId, {
+      startSeqNo,
+      lastPrimaryTerm,
+      logRetentionBytes: replicationConfig?.logRetentionBytes
+    })
   );
 }
-async function reconcileOne(deps, indexName) {
-  const localUuid = deps.engine.indexUuidOf(indexName);
-  let clusterUuid;
-  try {
-    clusterUuid = (await getIndexMetadata(deps.coordinator, indexName))?.indexUuid ?? null;
-  } catch (error) {
-    report(deps, indexName, `its metadata could not be read: ${describeError(error)}`);
-    return "orphaned";
-  }
-  if (clusterUuid === null) {
-    report(deps, indexName, "the coordinator holds no metadata for that name");
-    return "orphaned";
-  }
-  if (localUuid === clusterUuid) {
-    return "adopted";
+function deleteIndexReplicationLogs(replicationLogs, indexName) {
+  const prefix = `${indexName}:`;
+  for (const key of replicationLogs.keys()) {
+    if (key.startsWith(prefix)) replicationLogs.delete(key);
   }
-  if (localUuid === null || localUuid === void 0) {
-    await deps.engine.stampIndexUuid(indexName, clusterUuid);
-    return "adopted";
+}
+
+// src/distribution/cluster-node/local-replication.ts
+async function seedReopenedPrimaryLogs(input) {
+  const allocation = await input.coordinator.getAllocation(input.indexName);
+  if (allocation === null) return;
+  for (const partitionId of input.engine.heldPartitionsOf(input.indexName) ?? []) {
+    const assignment = allocation.assignments.get(partitionId);
+    if (assignment?.primary !== input.nodeId) continue;
+    const floor = Math.max(input.engine.highestPersistedSeqNoOf(input.indexName, partitionId), assignment.commitPoint);
+    seedReplicationLog(
+      input.replicationLogs,
+      input.indexName,
+      partitionId,
+      floor + 1,
+      assignment.primaryTerm,
+      input.replicationConfig
+    );
   }
-  await deps.engine.dropIndex(indexName);
-  return "superseded";
 }
-function report(deps, indexName, reason) {
-  if (deps.onError === void 0) {
-    return;
+async function applyLocalReplicationEntry(core, entry) {
+  core.guardShutdown();
+  const release = await core.indexState.acquire(entry.indexName);
+  try {
+    const indexEntry = core.requireIndex(entry.indexName);
+    const manager = core.requireManager(entry.indexName);
+    const vecIndexes = manager.getVectorIndexes();
+    if (entry.operation === "INDEX") {
+      applyIndexEntry(entry, manager, indexEntry.vectorFieldPaths, vecIndexes);
+      const appliedDocument = manager.get(entry.documentId);
+      if (appliedDocument !== void 0) {
+        await core.orchestrator.replicateToWorkers({
+          type: "insert",
+          indexName: entry.indexName,
+          docId: entry.documentId,
+          document: appliedDocument,
+          requestId: `replicate-entry-insert-${entry.indexName}-${entry.partitionId}-${entry.seqNo}`
+        });
+      }
+      return;
+    }
+    applyDeleteEntry(entry, manager, vecIndexes);
+    await core.orchestrator.replicateToWorkers({
+      type: "remove",
+      indexName: entry.indexName,
+      docId: entry.documentId,
+      requestId: `replicate-entry-remove-${entry.indexName}-${entry.partitionId}-${entry.seqNo}`
+    });
+  } finally {
+    release();
   }
-  deps.onError(
-    new NarsilError(
-      ErrorCodes.INDEX_ORPHANED,
-      `Node '${deps.nodeId}' holds a local copy of index '${indexName}' the cluster does not claim, because ${reason}. The node keeps the data and serves none of it until an operator drops it.`,
-      { indexName, nodeId: deps.nodeId }
-    )
-  );
 }
 
-// src/distribution/cluster-node/snapshot-auth.ts
-var BOOTSTRAPPABLE_STATES = /* @__PURE__ */ new Set(["ACTIVE", "INITIALISING", "MIGRATING"]);
-async function authorizeSnapshotRequest(coordinator, indexName, sourceId) {
-  let allocation;
-  try {
-    allocation = await coordinator.getAllocation(indexName);
-  } catch (err) {
-    const errMessage = err instanceof Error ? err.message : String(err);
-    return {
-      outcome: "denied",
-      code: ErrorCodes.SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE,
-      reason: `allocation lookup failed: ${errMessage}`
-    };
+// src/distribution/cluster-node/local-engine.ts
+async function createClusterLocalEngine(config, hooks) {
+  const core = createEngineCore(config, hooks);
+  if (core.durability !== null) {
+    await core.durability.manager.recover(config?.lifecycle !== void 0);
   }
-  if (allocation === null) {
-    return {
-      outcome: "denied",
-      code: ErrorCodes.SNAPSHOT_SYNC_UNAUTHORIZED,
-      reason: `index '${indexName}' has no allocation`
-    };
+  if (core.invalidation !== null) {
+    await core.invalidation.start();
   }
-  let sawAssignment = false;
-  for (const assignment of allocation.assignments.values()) {
-    const isAssigned = assignment.primary === sourceId || assignment.replicas.includes(sourceId);
-    if (!isAssigned) {
-      continue;
-    }
-    sawAssignment = true;
-    if (!BOOTSTRAPPABLE_STATES.has(assignment.state)) {
-      continue;
+  if (config?.lifecycle === void 0) await core.analysisRebuild.reviewStaleIndexes();
+  const engine = createNarsilFromCore(core, config);
+  const heldPartitions = createHeldPartitionRecord(core);
+  return Object.assign(engine, {
+    createIndexWithUuid: (name, indexConfig, indexUuid) => createEngineIndex(core, config, name, indexConfig, indexUuid),
+    acquireIndexForReplication: (indexName) => core.indexState.acquire(indexName, false),
+    indexUuidOf: (indexName) => core.indexRegistry.get(indexName)?.indexUuid,
+    stampIndexUuid: (indexName, indexUuid) => stampIndexUuid(core, indexName, indexUuid),
+    highestPersistedSeqNoOf: (indexName, partitionId) => core.durability?.manager.highestPersistedSeqNo(indexName, partitionId) ?? 0,
+    heldPartitionsOf: (indexName) => heldPartitions.held(indexName),
+    recordHeldPartition: (indexName, partitionId) => heldPartitions.record(indexName, partitionId),
+    forgetHeldPartition: (indexName, partitionId) => heldPartitions.forget(indexName, partitionId),
+    applyReplicationEntry: (entry) => applyLocalReplicationEntry(core, entry),
+    serializeReplicationPartition: (indexName, partitionId) => serializeReplicationPartition(core, indexName, partitionId),
+    restoreReplicationPartition: (indexName, partitionId, bytes, schema, partitionCount) => restoreReplicationPartition(core, engine, indexName, partitionId, bytes, schema, partitionCount),
+    queryPartitions: (indexName, params, partitionIds, globalStats) => runEngineQuery(core, indexName, params, { partitionIds, globalStats }),
+    preflightPartitions: (indexName, params, partitionIds) => runEnginePreflight(core, indexName, params, { partitionIds }),
+    suggestPartitions: (indexName, params, partitionIds) => runEngineSuggest(core, indexName, params, partitionIds),
+    listPartitions: (indexName, params, partitionIds) => runEngineListDocuments(core, indexName, params, partitionIds),
+    collectQueryStats: (indexName, terms, partitionIds) => runEngineQueryStats(core, indexName, terms, partitionIds),
+    partitionStatsForRead: async (indexName) => {
+      const release = await core.indexState.acquire(indexName);
+      try {
+        return core.requireManager(indexName).getPartitionStats();
+      } finally {
+        release();
+      }
     }
-    return { outcome: "authorized" };
+  });
+}
+async function stampIndexUuid(core, indexName, indexUuid) {
+  const entry = core.indexRegistry.get(indexName);
+  if (entry === void 0 || entry.indexUuid === indexUuid) {
+    return;
   }
-  if (sawAssignment) {
-    return {
-      outcome: "denied",
-      code: ErrorCodes.SNAPSHOT_SYNC_NOT_ASSIGNED,
-      reason: `node '${sourceId}' is listed for index '${indexName}' but not in a bootstrappable state`
-    };
+  core.indexRegistry.set(indexName, { ...entry, indexUuid });
+  if (core.durability !== null) {
+    await core.durability.manager.persistMetadata(indexName);
   }
-  return {
-    outcome: "denied",
-    code: ErrorCodes.SNAPSHOT_SYNC_UNAUTHORIZED,
-    reason: `node '${sourceId}' is not an assigned replica for index '${indexName}'`
-  };
 }
-
-// src/distribution/cluster-node/snapshot-cache.ts
-var DEFAULT_MAX_CONCURRENT_SNAPSHOTS = 2;
-var DEFAULT_MAX_PER_SOURCE_SNAPSHOTS = 1;
-var DEFAULT_MAX_STREAMS_PER_INDEX = 4;
-function createSnapshotCacheState(maxConcurrent = DEFAULT_MAX_CONCURRENT_SNAPSHOTS, maxPerSource = DEFAULT_MAX_PER_SOURCE_SNAPSHOTS, maxStreamsPerIndex = DEFAULT_MAX_STREAMS_PER_INDEX) {
-  if (!Number.isInteger(maxConcurrent) || maxConcurrent <= 0) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "maxConcurrent must be a positive integer", {
-      maxConcurrent
-    });
+async function serializeReplicationPartition(core, indexName, partitionId) {
+  core.guardShutdown();
+  const release = await core.indexState.acquire(indexName, false);
+  try {
+    return core.requireManager(indexName).serializePartitionToBytes(partitionId);
+  } finally {
+    release();
   }
-  if (!Number.isInteger(maxPerSource) || maxPerSource <= 0) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "maxPerSource must be a positive integer", {
-      maxPerSource
+}
+async function restoreReplicationPartition(core, engine, indexName, partitionId, bytes, schema, partitionCount) {
+  core.guardShutdown();
+  validatePartitionRestoreTarget(indexName, partitionId, partitionCount);
+  let partition;
+  try {
+    partition = deserializePayloadV2(bytes);
+  } catch (err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, `partition snapshot decode failed: ${cause}`, {
+      indexName,
+      partitionId,
+      cause
     });
   }
-  if (!Number.isInteger(maxStreamsPerIndex) || maxStreamsPerIndex <= 0) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "maxStreamsPerIndex must be a positive integer", {
-      maxStreamsPerIndex
+  validatePartitionSnapshotPayload(indexName, partitionId, partitionCount, schema, partition);
+  const trackPositions = core.indexRegistry.get(indexName)?.config.trackPositions ?? true;
+  createPartitionIndex(partitionId, trackPositions).deserialize(partition, schema);
+  let release = core.indexRegistry.has(indexName) ? await core.indexState.acquire(indexName, false) : null;
+  try {
+    const restoreIndex = await ensureReplicationIndex(
+      core,
+      engine,
+      indexName,
+      schema,
+      partition.language,
+      partitionCount
+    );
+    if (release === null) release = await core.indexState.acquire(indexName, false);
+    if (restoreIndex.created) {
+      await core.orchestrator.replicateToWorkers({
+        type: "createIndex",
+        indexName,
+        config: restoreIndex.config,
+        requestId: `replicate-partition-index-${indexName}`
+      });
+    }
+    const manager = core.requireManager(indexName);
+    manager.deserializePartition(partitionId, partition);
+    await core.orchestrator.replicateToWorkers({
+      type: "deserialize",
+      indexName,
+      partitionId,
+      data: partition,
+      requestId: `replicate-partition-restore-${indexName}-${partitionId}`
     });
+  } finally {
+    release?.();
   }
-  return {
-    cache: /* @__PURE__ */ new Map(),
-    active: 0,
-    perSource: /* @__PURE__ */ new Map(),
-    streamActive: /* @__PURE__ */ new Map(),
-    maxConcurrent,
-    maxPerSource,
-    maxStreamsPerIndex
-  };
-}
-function sourceSlotKey(sourceId, indexName) {
-  return `${sourceId}\0${indexName}`;
 }
-function acquireSourceSlot(state, sourceId, indexName) {
-  const key = sourceSlotKey(sourceId, indexName);
-  const current = state.perSource.get(key) ?? 0;
-  if (current >= state.maxPerSource) {
+function validatePartitionRestoreTarget(indexName, partitionId, partitionCount) {
+  if (!Number.isInteger(partitionId) || partitionId < 0) {
+    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partitionId must be a non-negative integer", {
+      indexName,
+      partitionId
+    });
+  }
+  if (!Number.isInteger(partitionCount) || partitionCount <= 0 || partitionCount > MAX_PARTITION_COUNT) {
     throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_CAPACITY_EXHAUSTED,
-      `snapshot producer per-source cap reached for '${sourceId}' index '${indexName}'`,
-      { sourceId, indexName, cap: state.maxPerSource }
+      ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED,
+      `partitionCount must be an integer between 1 and ${MAX_PARTITION_COUNT}`,
+      { indexName, partitionCount }
     );
   }
-  state.perSource.set(key, current + 1);
-  return { key, released: false };
+  if (partitionId >= partitionCount) {
+    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partitionId is outside partitionCount", {
+      indexName,
+      partitionId,
+      partitionCount
+    });
+  }
 }
-function releaseSourceSlot(state, handle) {
-  if (handle.released) {
-    return;
+function validatePartitionSnapshotPayload(indexName, partitionId, partitionCount, schema, partition) {
+  if (partition.indexName !== indexName) {
+    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot indexName mismatch", {
+      expectedIndexName: indexName,
+      receivedIndexName: partition.indexName
+    });
   }
-  handle.released = true;
-  const current = state.perSource.get(handle.key);
-  if (current === void 0) {
-    return;
+  if (partition.partitionId !== partitionId) {
+    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot partitionId mismatch", {
+      indexName,
+      expectedPartitionId: partitionId,
+      receivedPartitionId: partition.partitionId
+    });
   }
-  if (current <= 1) {
-    state.perSource.delete(handle.key);
-    return;
+  if (partition.totalPartitions !== partitionCount) {
+    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot partition count mismatch", {
+      indexName,
+      partitionId,
+      expectedPartitionCount: partitionCount,
+      receivedPartitionCount: partition.totalPartitions
+    });
   }
-  state.perSource.set(handle.key, current - 1);
-}
-function acquireStreamSlot(state, indexName) {
-  const current = state.streamActive.get(indexName) ?? 0;
-  if (current >= state.maxStreamsPerIndex) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_CAPACITY_EXHAUSTED,
-      `snapshot stream fan-out cap reached for index '${indexName}'`,
-      { indexName, cap: state.maxStreamsPerIndex }
-    );
+  const expectedSchema = flattenSchema(schema);
+  for (const [field, expectedType] of Object.entries(expectedSchema)) {
+    if (partition.schema[field] !== expectedType) {
+      throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot schema mismatch", {
+        indexName,
+        partitionId,
+        field,
+        expected: expectedType,
+        received: partition.schema[field] ?? "(absent)"
+      });
+    }
+  }
+  for (const field of Object.keys(partition.schema)) {
+    if (!(field in expectedSchema)) {
+      throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot schema contains extra field", {
+        indexName,
+        partitionId,
+        field
+      });
+    }
   }
-  state.streamActive.set(indexName, current + 1);
-  return { indexName, released: false };
 }
-function releaseStreamSlot(state, handle) {
-  if (handle.released) {
-    return;
+async function ensureReplicationIndex(core, engine, indexName, schema, languageName, partitionCount) {
+  const language = getLanguage(languageName);
+  const existing = core.indexRegistry.get(indexName);
+  let created = false;
+  if (existing === void 0) {
+    const indexConfig = {
+      schema,
+      language: language.name,
+      partitions: { maxPartitions: partitionCount }
+    };
+    try {
+      await engine.createIndex(indexName, indexConfig);
+      created = true;
+    } catch (err) {
+      if (!(err instanceof NarsilError) || err.code !== ErrorCodes.INDEX_ALREADY_EXISTS) {
+        throw err;
+      }
+    }
   }
-  handle.released = true;
-  const current = state.streamActive.get(handle.indexName);
-  if (current === void 0) {
-    return;
+  const entry = core.requireIndex(indexName);
+  if (entry.language.name !== language.name) {
+    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "partition snapshot language mismatch", {
+      indexName,
+      expectedLanguage: entry.language.name,
+      receivedLanguage: language.name
+    });
   }
-  if (current <= 1) {
-    state.streamActive.delete(handle.indexName);
-    return;
+  validateExistingSchema(indexName, schema, entry.config.schema);
+  const manager = core.requireManager(indexName);
+  if (manager.partitionCount > partitionCount) {
+    throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "local index has more partitions than allocation", {
+      indexName,
+      localPartitionCount: manager.partitionCount,
+      allocationPartitionCount: partitionCount
+    });
   }
-  state.streamActive.set(handle.indexName, current - 1);
-}
-async function acquireSnapshotBuild(state, indexName, builder) {
-  const existing = state.cache.get(indexName);
-  if (existing !== void 0) {
-    return existing.promise;
+  if (entry.config.partitions === void 0) {
+    entry.config.partitions = { maxPartitions: partitionCount };
+  } else if ((entry.config.partitions.maxPartitions ?? manager.partitionCount) < partitionCount) {
+    entry.config.partitions.maxPartitions = partitionCount;
   }
-  if (state.active >= state.maxConcurrent) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_CAPACITY_EXHAUSTED,
-      "snapshot producer capacity exhausted; retry later",
-      { active: state.active, max: state.maxConcurrent }
+  while (manager.partitionCount < partitionCount) {
+    manager.addPartition();
+  }
+  return { config: entry.config, created };
+}
+function validateExistingSchema(indexName, expected, actual) {
+  const expectedSchema = flattenSchema(expected);
+  const actualSchema = flattenSchema(actual);
+  for (const [field, expectedType] of Object.entries(expectedSchema)) {
+    if (actualSchema[field] !== expectedType) {
+      throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "local index schema mismatch", {
+        indexName,
+        field,
+        expected: expectedType,
+        received: actualSchema[field] ?? "(absent)"
+      });
+    }
+  }
+  for (const field of Object.keys(actualSchema)) {
+    if (!(field in expectedSchema)) {
+      throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "local index schema contains extra field", {
+        indexName,
+        field
+      });
+    }
+  }
+}
+function flattenSchema(schema) {
+  const flat = {};
+  flattenSchemaInto(schema, "", flat);
+  return flat;
+}
+function flattenSchemaInto(schema, prefix, flat) {
+  for (const [field, value] of Object.entries(schema)) {
+    const path = prefix.length === 0 ? field : `${prefix}.${field}`;
+    if (isNestedSchema(value)) {
+      flattenSchemaInto(value, path, flat);
+      continue;
+    }
+    flat[path] = value;
+  }
+}
+function isNestedSchema(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/distribution/cluster-node/local-index-reconcile.ts
+async function reconcileLocalIndexes(deps) {
+  const dispositions = /* @__PURE__ */ new Map();
+  for (const index of deps.engine.listIndexes()) {
+    const disposition = await reconcileOne(deps, index.name);
+    dispositions.set(index.name, disposition);
+  }
+  return dispositions;
+}
+async function adoptClusterIdentity(engine, coordinator, indexName) {
+  if (engine.indexUuidOf(indexName) !== null) {
+    return;
+  }
+  const metadata = await getIndexMetadata(coordinator, indexName);
+  if (metadata === null) {
+    return;
+  }
+  await engine.stampIndexUuid(indexName, metadata.indexUuid);
+}
+function orphanedIndexError(nodeId, indexName) {
+  return new NarsilError(
+    ErrorCodes.INDEX_ORPHANED,
+    `Node '${nodeId}' holds a local copy of index '${indexName}' the cluster does not claim, so it answers nothing for that name. Drop it to reclaim the space`,
+    { indexName, nodeId }
+  );
+}
+async function reconcileOne(deps, indexName) {
+  const localUuid = deps.engine.indexUuidOf(indexName);
+  let clusterUuid;
+  try {
+    clusterUuid = (await getIndexMetadata(deps.coordinator, indexName))?.indexUuid ?? null;
+  } catch (error) {
+    report(deps, indexName, `its metadata could not be read: ${describeError(error)}`);
+    return "orphaned";
+  }
+  if (clusterUuid === null) {
+    report(deps, indexName, "the coordinator holds no metadata for that name");
+    return "orphaned";
+  }
+  if (localUuid === clusterUuid) {
+    return "adopted";
+  }
+  if (localUuid === null || localUuid === void 0) {
+    await deps.engine.stampIndexUuid(indexName, clusterUuid);
+    return "adopted";
+  }
+  await deps.engine.dropIndex(indexName);
+  return "superseded";
+}
+function report(deps, indexName, reason) {
+  if (deps.onError === void 0) {
+    return;
+  }
+  deps.onError(
+    new NarsilError(
+      ErrorCodes.INDEX_ORPHANED,
+      `Node '${deps.nodeId}' holds a local copy of index '${indexName}' the cluster does not claim, because ${reason}. The node keeps the data and serves none of it until an operator drops it.`,
+      { indexName, nodeId: deps.nodeId }
+    )
+  );
+}
+
+// src/distribution/cluster-node/snapshot-auth.ts
+var BOOTSTRAPPABLE_STATES = /* @__PURE__ */ new Set(["ACTIVE", "INITIALISING", "MIGRATING"]);
+async function authorizeSnapshotRequest(coordinator, indexName, sourceId) {
+  let allocation;
+  try {
+    allocation = await coordinator.getAllocation(indexName);
+  } catch (err) {
+    const errMessage = err instanceof Error ? err.message : String(err);
+    return {
+      outcome: "denied",
+      code: ErrorCodes.SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE,
+      reason: `allocation lookup failed: ${errMessage}`
+    };
+  }
+  if (allocation === null) {
+    return {
+      outcome: "denied",
+      code: ErrorCodes.SNAPSHOT_SYNC_UNAUTHORIZED,
+      reason: `index '${indexName}' has no allocation`
+    };
+  }
+  let sawAssignment = false;
+  for (const assignment of allocation.assignments.values()) {
+    const isAssigned = assignment.primary === sourceId || assignment.replicas.includes(sourceId);
+    if (!isAssigned) {
+      continue;
+    }
+    sawAssignment = true;
+    if (!BOOTSTRAPPABLE_STATES.has(assignment.state)) {
+      continue;
+    }
+    return { outcome: "authorized" };
+  }
+  if (sawAssignment) {
+    return {
+      outcome: "denied",
+      code: ErrorCodes.SNAPSHOT_SYNC_NOT_ASSIGNED,
+      reason: `node '${sourceId}' is listed for index '${indexName}' but not in a bootstrappable state`
+    };
+  }
+  return {
+    outcome: "denied",
+    code: ErrorCodes.SNAPSHOT_SYNC_UNAUTHORIZED,
+    reason: `node '${sourceId}' is not an assigned replica for index '${indexName}'`
+  };
+}
+
+// src/distribution/cluster-node/snapshot-cache.ts
+var DEFAULT_MAX_CONCURRENT_SNAPSHOTS = 2;
+var DEFAULT_MAX_PER_SOURCE_SNAPSHOTS = 1;
+var DEFAULT_MAX_STREAMS_PER_INDEX = 4;
+function createSnapshotCacheState(maxConcurrent = DEFAULT_MAX_CONCURRENT_SNAPSHOTS, maxPerSource = DEFAULT_MAX_PER_SOURCE_SNAPSHOTS, maxStreamsPerIndex = DEFAULT_MAX_STREAMS_PER_INDEX) {
+  if (!Number.isInteger(maxConcurrent) || maxConcurrent <= 0) {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "maxConcurrent must be a positive integer", {
+      maxConcurrent
+    });
+  }
+  if (!Number.isInteger(maxPerSource) || maxPerSource <= 0) {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "maxPerSource must be a positive integer", {
+      maxPerSource
+    });
+  }
+  if (!Number.isInteger(maxStreamsPerIndex) || maxStreamsPerIndex <= 0) {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "maxStreamsPerIndex must be a positive integer", {
+      maxStreamsPerIndex
+    });
+  }
+  return {
+    cache: /* @__PURE__ */ new Map(),
+    active: 0,
+    perSource: /* @__PURE__ */ new Map(),
+    streamActive: /* @__PURE__ */ new Map(),
+    maxConcurrent,
+    maxPerSource,
+    maxStreamsPerIndex
+  };
+}
+function sourceSlotKey(sourceId, indexName) {
+  return `${sourceId}\0${indexName}`;
+}
+function acquireSourceSlot(state, sourceId, indexName) {
+  const key = sourceSlotKey(sourceId, indexName);
+  const current = state.perSource.get(key) ?? 0;
+  if (current >= state.maxPerSource) {
+    throw new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_CAPACITY_EXHAUSTED,
+      `snapshot producer per-source cap reached for '${sourceId}' index '${indexName}'`,
+      { sourceId, indexName, cap: state.maxPerSource }
+    );
+  }
+  state.perSource.set(key, current + 1);
+  return { key, released: false };
+}
+function releaseSourceSlot(state, handle) {
+  if (handle.released) {
+    return;
+  }
+  handle.released = true;
+  const current = state.perSource.get(handle.key);
+  if (current === void 0) {
+    return;
+  }
+  if (current <= 1) {
+    state.perSource.delete(handle.key);
+    return;
+  }
+  state.perSource.set(handle.key, current - 1);
+}
+function acquireStreamSlot(state, indexName) {
+  const current = state.streamActive.get(indexName) ?? 0;
+  if (current >= state.maxStreamsPerIndex) {
+    throw new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_CAPACITY_EXHAUSTED,
+      `snapshot stream fan-out cap reached for index '${indexName}'`,
+      { indexName, cap: state.maxStreamsPerIndex }
+    );
+  }
+  state.streamActive.set(indexName, current + 1);
+  return { indexName, released: false };
+}
+function releaseStreamSlot(state, handle) {
+  if (handle.released) {
+    return;
+  }
+  handle.released = true;
+  const current = state.streamActive.get(handle.indexName);
+  if (current === void 0) {
+    return;
+  }
+  if (current <= 1) {
+    state.streamActive.delete(handle.indexName);
+    return;
+  }
+  state.streamActive.set(handle.indexName, current - 1);
+}
+async function acquireSnapshotBuild(state, indexName, builder) {
+  const existing = state.cache.get(indexName);
+  if (existing !== void 0) {
+    return existing.promise;
+  }
+  if (state.active >= state.maxConcurrent) {
+    throw new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_CAPACITY_EXHAUSTED,
+      "snapshot producer capacity exhausted; retry later",
+      { active: state.active, max: state.maxConcurrent }
     );
   }
   state.active += 1;
@@ -7429,7 +7722,7 @@ async function handleFetch(message, respond, deps) {
 async function handleStats(message, respond, deps) {
   const decoded = decode(message.payload);
   const payload = validateStatsPayload(decoded);
-  const resultPayload = deps.engine.collectQueryStats(
+  const resultPayload = await deps.engine.collectQueryStats(
     payload.indexName,
     payload.terms,
     payload.partitionIds
@@ -7470,7 +7763,7 @@ function convertLocalFacetsToWire2(facets) {
 async function handleCount(message, respond, deps) {
   const payload = validateCountPayload(decode(message.payload));
   const requested = new Set(payload.partitionIds);
-  const partitions = deps.engine.getPartitionStats(payload.indexName).filter((partition) => requested.has(partition.partitionId)).map((partition) => ({
+  const partitions = (await deps.engine.partitionStatsForRead(payload.indexName)).filter((partition) => requested.has(partition.partitionId)).map((partition) => ({
     partitionId: partition.partitionId,
     documentCount: partition.documentCount,
     estimatedMemoryBytes: partition.estimatedMemoryBytes
@@ -7620,59 +7913,65 @@ async function handleSyncRequestMessage(message, respond, deps) {
       }
     );
   }
-  if (!deps.engine.listIndexes().some((index) => index.name === request.indexName)) {
+  const localIndex = deps.engine.listIndexes().find((index) => index.name === request.indexName);
+  if (localIndex === void 0) {
     throw new NarsilError(
       ErrorCodes.SNAPSHOT_SYNC_INDEX_NOT_FOUND,
       `Node '${deps.nodeId}' holds no copy of index '${request.indexName}' yet, so it cannot serve a sync for partition ${request.partitionId}`,
       { indexName: request.indexName, partitionId: request.partitionId, primaryNodeId: deps.nodeId }
     );
   }
-  if (message.sourceId !== deps.nodeId) {
-    recordReplicaPosition(
-      deps.writeDeps.catchUp,
-      request.indexName,
-      request.partitionId,
-      message.sourceId,
-      request.lastSeqNo
-    );
-  }
-  const log = deps.writeDeps.getReplicationLog(request.indexName, request.partitionId);
-  const tier = decideSyncTier(log, request.lastSeqNo);
-  if (tier === "incremental") {
-    await sendSyncEntriesResponse(message, respond, deps, log.getEntriesFrom(request.lastSeqNo + 1));
-    return;
-  }
-  const snapshotSeqNo = log.localLogEnd;
-  const sink = createSingleResponseSink(respond);
-  await streamValidatedSnapshotRequest(
-    message,
-    sink,
-    { indexName: request.indexName, partitionId: request.partitionId },
-    {
-      nodeId: deps.nodeId,
-      engine: deps.engine,
-      coordinator: deps.coordinator,
-      state: deps.snapshotSyncState,
-      resolveHeaderMetadata: deps.resolveHeaderMetadata
-    },
-    {
-      metadata: {
-        partitionId: request.partitionId,
-        lastSeqNo: snapshotSeqNo,
-        primaryTerm: assignment.primaryTerm
-      },
-      closeOnEnd: false,
-      disableBuildCache: true,
-      buildSnapshot: async () => {
-        const bytes = await deps.engine.serializeReplicationPartition(request.indexName, request.partitionId);
-        return { bytes, checksum: crc32(bytes) };
+  const release = await deps.engine.acquireIndexForReplication(request.indexName);
+  try {
+    if (message.sourceId !== deps.nodeId) {
+      recordReplicaPosition(
+        deps.writeDeps.catchUp,
+        request.indexName,
+        request.partitionId,
+        message.sourceId,
+        request.lastSeqNo
+      );
+    }
+    const log = deps.writeDeps.getReplicationLog(request.indexName, request.partitionId);
+    const tier = decideSyncTier(log, request.lastSeqNo);
+    if (tier === "incremental") {
+      await sendSyncEntriesResponse(message, respond, deps, log.getEntriesFrom(request.lastSeqNo + 1));
+      return;
+    }
+    const snapshotSeqNo = log.localLogEnd;
+    const sink = createSingleResponseSink(respond);
+    await streamValidatedSnapshotRequest(
+      message,
+      sink,
+      { indexName: request.indexName, partitionId: request.partitionId },
+      {
+        nodeId: deps.nodeId,
+        engine: deps.engine,
+        coordinator: deps.coordinator,
+        state: deps.snapshotSyncState,
+        resolveHeaderMetadata: deps.resolveHeaderMetadata
       },
-      afterSnapshot: async (trailingSink) => {
-        const entries = log.getEntriesFrom(snapshotSeqNo + 1);
-        await sendSyncEntriesResponse(message, trailingSink, deps, entries);
+      {
+        metadata: {
+          partitionId: request.partitionId,
+          lastSeqNo: snapshotSeqNo,
+          primaryTerm: assignment.primaryTerm
+        },
+        closeOnEnd: false,
+        disableBuildCache: true,
+        buildSnapshot: async () => {
+          const bytes = await deps.engine.serializeReplicationPartition(request.indexName, request.partitionId);
+          return { bytes, checksum: crc32(bytes) };
+        },
+        afterSnapshot: async (trailingSink) => {
+          const entries = log.getEntriesFrom(snapshotSeqNo + 1);
+          await sendSyncEntriesResponse(message, trailingSink, deps, entries);
+        }
       }
-    }
-  );
+    );
+  } finally {
+    release();
+  }
 }
 async function sendSyncEntriesResponse(message, respond, deps, entries) {
   const payload = {
@@ -10120,7 +10419,7 @@ async function gatherPartitionCounts(deps, indexName, allocation) {
     groups.map(async (group) => {
       if (group.nodeId === deps.nodeId) {
         const requested = new Set(group.partitionIds);
-        const partitions = deps.engine.getPartitionStats(indexName).filter((partition) => requested.has(partition.partitionId)).map((partition) => ({
+        const partitions = (await deps.engine.partitionStatsForRead(indexName)).filter((partition) => requested.has(partition.partitionId)).map((partition) => ({
           partitionId: partition.partitionId,
           documentCount: partition.documentCount,
           estimatedMemoryBytes: partition.estimatedMemoryBytes
@@ -10198,7 +10497,7 @@ async function statsCluster(deps, indexName) {
 async function partitionStatsCluster(deps, indexName) {
   const allocation = await routableAllocation(deps.config.coordinator, indexName);
   if (allocation === null) {
-    return deps.engine.getPartitionStats(indexName);
+    return deps.engine.partitionStatsForRead(indexName);
   }
   const { countsByPartition } = await gatherPartitionCounts(deps, indexName, allocation);
   return Array.from(countsByPartition.entries()).map(([partitionId, entry]) => ({
@@ -10486,391 +10785,234 @@ async function clearCluster(readDeps, writeDeps, indexName) {
   }
   for (; ; ) {
     const page = await listCluster(readDeps, indexName, { limit: CLEAR_PAGE_SIZE, document: false });
-    if (page.documents.length === 0) {
-      return;
-    }
-    const result = await routeRemoveBatch(
-      indexName,
-      page.documents.map((listed) => listed.id),
-      writeDeps
-    );
-    if (result.succeeded.length === 0) {
-      const firstFailure = result.failed[0];
-      throw new NarsilError(
-        ErrorCodes.QUERY_ROUTING_FAILED,
-        `Clearing index '${indexName}' stalled: no document in the current page could be removed`,
-        {
-          indexName,
-          remaining: page.total,
-          firstFailureDocId: firstFailure?.docId,
-          firstFailureCode: firstFailure?.error.code,
-          firstFailureMessage: firstFailure?.error.message
-        }
-      );
-    }
-  }
-}
-
-// src/distribution/cluster-node/node-operations.ts
-function createClusterNodeOperations(deps) {
-  const { trackOp, readDeps, writeDeps, engine, coordinator } = deps;
-  return {
-    async createIndex(name, indexConfig, options) {
-      return trackOp(name, () => routeCreateIndex(name, indexConfig, options, coordinator, engine));
-    },
-    async insert(indexName, document, docId, options) {
-      return trackOp(indexName, () => routeInsert(indexName, document, docId, writeDeps, options));
-    },
-    async insertBatch(indexName, documents, options) {
-      return trackOp(indexName, () => routeInsertBatch(indexName, documents, writeDeps, options));
-    },
-    async remove(indexName, docId) {
-      return trackOp(indexName, () => routeRemove(indexName, docId, writeDeps));
-    },
-    async removeBatch(indexName, docIds) {
-      return trackOp(indexName, () => routeRemoveBatch(indexName, docIds, writeDeps));
-    },
-    async update(indexName, docId, document) {
-      return trackOp(indexName, () => routeUpdate(indexName, docId, document, writeDeps));
-    },
-    async updateBatch(indexName, updates) {
-      return trackOp(indexName, () => routeUpdateBatch(indexName, updates, writeDeps));
-    },
-    async dropIndex(name) {
-      return trackOp(null, async () => {
-        await routeDropIndex(name, coordinator, engine);
-        deps.forgetIndex(name);
-      });
-    },
-    async clear(indexName) {
-      return trackOp(indexName, () => clearCluster(readDeps, writeDeps, indexName));
-    },
-    async countDocuments(indexName) {
-      return trackOp(indexName, () => countCluster(readDeps, indexName));
-    },
-    async listDocuments(indexName, params) {
-      return trackOp(indexName, () => listCluster(readDeps, indexName, params ?? {}));
-    },
-    async suggest(indexName, params) {
-      return trackOp(indexName, () => suggestCluster(readDeps, indexName, params));
-    },
-    async preflight(indexName, params) {
-      return trackOp(indexName, () => preflightCluster(readDeps, indexName, params));
-    },
-    async getStats(indexName) {
-      return trackOp(indexName, () => statsCluster(readDeps, indexName));
-    },
-    async getPartitionStats(indexName) {
-      return trackOp(indexName, () => partitionStatsCluster(readDeps, indexName));
-    },
-    async checkpoint(indexName) {
-      return trackOp(indexName, () => engine.checkpoint(indexName));
-    },
-    async getMemoryStats() {
-      return trackOp(null, () => engine.getMemoryStats());
-    },
-    on(event, handler) {
-      engine.on(event, handler);
-    },
-    off(event, handler) {
-      engine.off(event, handler);
-    },
-    async query(indexName, params) {
-      return trackOp(indexName, () => queryCluster(readDeps, indexName, params));
-    },
-    async get(indexName, docId) {
-      return trackOp(indexName, async () => (await readClusterDocuments(readDeps, indexName, [docId])).get(docId));
-    },
-    async getMultiple(indexName, docIds) {
-      return trackOp(indexName, () => readClusterDocuments(readDeps, indexName, docIds));
-    },
-    async has(indexName, docId) {
-      return trackOp(indexName, async () => (await readClusterDocuments(readDeps, indexName, [docId])).has(docId));
-    }
-  };
-}
-
-// src/distribution/cluster-node/primary-partition.ts
-async function preparePrimaryPartition(indexName, partitionId, deps) {
-  const schema = await deps.coordinator.getSchema(indexName);
-  if (schema === null) {
-    return false;
-  }
-  const allocation = await deps.coordinator.getAllocation(indexName);
-  if (allocation === null || allocation.assignments.size === 0) {
-    return false;
-  }
-  const existing = deps.engine.listIndexes().find((index) => index.name === indexName);
-  if (existing === void 0) {
-    try {
-      await deps.engine.createIndex(indexName, {
-        schema,
-        partitions: { maxPartitions: allocation.assignments.size }
-      });
-    } catch (error) {
-      if (!(error instanceof NarsilError) || error.code !== ErrorCodes.INDEX_ALREADY_EXISTS) {
-        deps.onError(error);
-        return false;
-      }
-    }
-  } else {
-    const schemaError = validateRestoredSchema(deps.engine, indexName, deps.nodeId, schema);
-    if (schemaError !== null) {
-      deps.onError(schemaError);
-      return false;
-    }
-  }
-  resumeNumberingAboveOwnCopy(indexName, partitionId, allocation.assignments.get(partitionId), deps);
-  return true;
-}
-function resumeNumberingAboveOwnCopy(indexName, partitionId, assignment, deps) {
-  if (assignment === void 0) {
-    return;
-  }
-  if (deps.replicationLogPosition(indexName, partitionId) > 0) {
-    return;
-  }
-  const floor = Math.max(deps.engine.highestPersistedSeqNoOf(indexName, partitionId), assignment.commitPoint);
-  if (floor <= 0) {
-    return;
-  }
-  deps.seedReplicationLog(indexName, partitionId, floor + 1, assignment.primaryTerm);
-}
-
-// src/distribution/replication/types.ts
-var DEFAULT_LOG_RETENTION_BYTES = 268435456;
-
-// src/distribution/replication/log.ts
-var ENTRY_FIXED_OVERHEAD_BYTES2 = 40;
-function estimateEntrySize(entry) {
-  return ENTRY_FIXED_OVERHEAD_BYTES2 + entry.indexName.length + entry.documentId.length + (entry.document?.byteLength ?? 0);
-}
-var computeChecksum = computeEntryChecksum;
-function createReplicationLog(partitionId, config) {
-  const retentionBytes = config?.logRetentionBytes ?? DEFAULT_LOG_RETENTION_BYTES;
-  let nextSeqNo = config?.startSeqNo ?? 1;
-  let localLogEnd = nextSeqNo - 1;
-  let localLogEndPrimaryTerm = config?.lastPrimaryTerm ?? 0;
-  let commitPoint = nextSeqNo - 1;
-  let entries = [];
-  let headIndex = 0;
-  let totalSizeBytes = 0;
-  function liveCount() {
-    return entries.length - headIndex;
-  }
-  function compact() {
-    if (headIndex > 0) {
-      entries = entries.slice(headIndex);
-      headIndex = 0;
-    }
-  }
-  function findIndexBySeqNo(seqNo) {
-    let low = headIndex;
-    let high = entries.length - 1;
-    while (low <= high) {
-      const mid = low + high >>> 1;
-      const midSeqNo = entries[mid].seqNo;
-      if (midSeqNo < seqNo) {
-        low = mid + 1;
-      } else if (midSeqNo > seqNo) {
-        high = mid - 1;
-      } else {
-        return mid;
-      }
-    }
-    return low;
-  }
-  function evictOldEntries() {
-    while (liveCount() > 0 && totalSizeBytes > retentionBytes) {
-      totalSizeBytes -= estimateEntrySize(entries[headIndex]);
-      entries[headIndex] = null;
-      headIndex += 1;
-    }
-    if (totalSizeBytes < 0) {
-      totalSizeBytes = 0;
-    }
-    if (headIndex >= 256 || headIndex > liveCount()) {
-      compact();
-    }
-  }
-  function assertEntryFitsRetention(entry) {
-    const entrySize = ENTRY_FIXED_OVERHEAD_BYTES2 + entry.indexName.length + entry.documentId.length + (entry.document?.byteLength ?? 0);
-    if (entrySize > retentionBytes) {
-      throw new NarsilError(
-        ErrorCodes.REPLICATION_LOG_FULL,
-        `Replication log entry of ${entrySize} bytes exceeds the log retention limit of ${retentionBytes} bytes and cannot be buffered`,
-        { partitionId, entrySize, retentionBytes, seqNo: entry.seqNo }
-      );
-    }
-  }
-  function storeEntry(entry) {
-    entries.push(entry);
-    if (entry.seqNo >= localLogEnd) {
-      localLogEnd = entry.seqNo;
-      localLogEndPrimaryTerm = entry.primaryTerm;
-    }
-    totalSizeBytes += estimateEntrySize(entry);
-    evictOldEntries();
-    return { ...entry };
-  }
-  function readEntry(seqNo) {
-    if (liveCount() === 0) return void 0;
-    const idx = findIndexBySeqNo(seqNo);
-    if (idx < entries.length && entries[idx].seqNo === seqNo) {
-      return { ...entries[idx] };
-    }
-    return void 0;
-  }
-  function verifyEntryChecksum(entry) {
-    const expected = computeChecksum({
-      seqNo: entry.seqNo,
-      primaryTerm: entry.primaryTerm,
-      operation: entry.operation,
-      partitionId: entry.partitionId,
-      indexName: entry.indexName,
-      documentId: entry.documentId,
-      document: entry.document
-    });
-    return expected === entry.checksum;
-  }
-  return {
-    append(partial) {
-      assertEntryFitsRetention(partial);
-      const seqNo = nextSeqNo;
-      nextSeqNo += 1;
-      const entryWithoutChecksum = {
-        seqNo,
-        primaryTerm: partial.primaryTerm,
-        operation: partial.operation,
-        partitionId,
-        indexName: partial.indexName,
-        documentId: partial.documentId,
-        document: partial.document
-      };
-      const checksum = computeChecksum(entryWithoutChecksum);
-      const entry = { ...entryWithoutChecksum, checksum };
-      return storeEntry(entry);
-    },
-    appendCommitted(entry) {
-      if (!Number.isSafeInteger(entry.seqNo) || entry.seqNo < 1) {
-        throw new NarsilError(
-          ErrorCodes.REPLICATION_ENTRY_INVALID,
-          `Invalid replication sequence number ${entry.seqNo}`,
-          {
-            seqNo: entry.seqNo,
-            partitionId
-          }
-        );
-      }
-      if (entry.partitionId !== partitionId) {
-        throw new NarsilError(
-          ErrorCodes.REPLICATION_ENTRY_INVALID,
-          `Replication entry partition ${entry.partitionId} does not match log partition ${partitionId}`,
-          { entryPartitionId: entry.partitionId, logPartitionId: partitionId }
-        );
-      }
-      const existing = readEntry(entry.seqNo);
-      if (existing !== void 0) {
-        if (existing.checksum !== entry.checksum) {
-          throw new NarsilError(
-            ErrorCodes.REPLICATION_ENTRY_INVALID,
-            `Conflicting replication entry at sequence number ${entry.seqNo}`,
-            { seqNo: entry.seqNo, partitionId }
-          );
+    if (page.documents.length === 0) {
+      return;
+    }
+    const result = await routeRemoveBatch(
+      indexName,
+      page.documents.map((listed) => listed.id),
+      writeDeps
+    );
+    if (result.succeeded.length === 0) {
+      const firstFailure = result.failed[0];
+      throw new NarsilError(
+        ErrorCodes.QUERY_ROUTING_FAILED,
+        `Clearing index '${indexName}' stalled: no document in the current page could be removed`,
+        {
+          indexName,
+          remaining: page.total,
+          firstFailureDocId: firstFailure?.docId,
+          firstFailureCode: firstFailure?.error.code,
+          firstFailureMessage: firstFailure?.error.message
         }
-        return existing;
-      }
-      if (entry.seqNo !== nextSeqNo) {
-        throw new NarsilError(
-          ErrorCodes.REPLICATION_ENTRY_INVALID,
-          `Out-of-order replication entry ${entry.seqNo}; expected ${nextSeqNo}`,
-          { seqNo: entry.seqNo, expectedSeqNo: nextSeqNo, partitionId }
-        );
-      }
-      if (!verifyEntryChecksum(entry)) {
-        throw new NarsilError(
-          ErrorCodes.REPLICATION_ENTRY_CORRUPT,
-          `Invalid checksum for replication entry ${entry.seqNo}`,
-          { seqNo: entry.seqNo, partitionId }
-        );
-      }
-      assertEntryFitsRetention(entry);
-      nextSeqNo = entry.seqNo + 1;
-      return storeEntry({ ...entry });
+      );
+    }
+  }
+}
+
+// src/distribution/cluster-node/node-operations.ts
+function createClusterNodeOperations(deps) {
+  const { trackOp, readDeps, writeDeps, engine, coordinator } = deps;
+  return {
+    async createIndex(name, indexConfig, options) {
+      return trackOp(name, () => routeCreateIndex(name, indexConfig, options, coordinator, engine));
     },
-    getEntriesFrom(fromSeqNo) {
-      if (liveCount() === 0) return [];
-      const idx = findIndexBySeqNo(fromSeqNo);
-      if (idx >= entries.length) return [];
-      return entries.slice(idx).map((e) => ({ ...e }));
+    async insert(indexName, document, docId, options) {
+      return trackOp(indexName, () => routeInsert(indexName, document, docId, writeDeps, options));
     },
-    getEntry(seqNo) {
-      return readEntry(seqNo);
+    async insertBatch(indexName, documents, options) {
+      return trackOp(indexName, () => routeInsertBatch(indexName, documents, writeDeps, options));
     },
-    verifyChecksum(entry) {
-      return verifyEntryChecksum(entry);
+    async remove(indexName, docId) {
+      return trackOp(indexName, () => routeRemove(indexName, docId, writeDeps));
     },
-    get localLogEnd() {
-      return localLogEnd;
+    async removeBatch(indexName, docIds) {
+      return trackOp(indexName, () => routeRemoveBatch(indexName, docIds, writeDeps));
     },
-    get localLogEndPrimaryTerm() {
-      return localLogEndPrimaryTerm;
+    async update(indexName, docId, document) {
+      return trackOp(indexName, () => routeUpdate(indexName, docId, document, writeDeps));
     },
-    get commitPoint() {
-      return commitPoint;
+    async updateBatch(indexName, updates) {
+      return trackOp(indexName, () => routeUpdateBatch(indexName, updates, writeDeps));
     },
-    advanceCommitPoint(seqNo) {
-      const bounded = Math.min(seqNo, localLogEnd);
-      if (bounded > commitPoint) {
-        commitPoint = bounded;
-      }
+    async dropIndex(name) {
+      return deps.transitionIndex(name, async () => {
+        await routeDropIndex(name, coordinator, engine);
+        deps.forgetIndex(name);
+      });
     },
-    get oldestSeqNo() {
-      if (liveCount() === 0) return void 0;
-      return entries[headIndex].seqNo;
+    async clear(indexName) {
+      return trackOp(indexName, () => clearCluster(readDeps, writeDeps, indexName));
     },
-    get newestSeqNo() {
-      if (liveCount() === 0) return void 0;
-      return entries[entries.length - 1].seqNo;
+    async countDocuments(indexName) {
+      return trackOp(indexName, () => countCluster(readDeps, indexName));
     },
-    get entryCount() {
-      return liveCount();
+    async listDocuments(indexName, params) {
+      return trackOp(indexName, () => listCluster(readDeps, indexName, params ?? {}));
     },
-    get sizeBytes() {
-      return totalSizeBytes;
+    async suggest(indexName, params) {
+      return trackOp(indexName, () => suggestCluster(readDeps, indexName, params));
     },
-    clear() {
-      entries = [];
-      headIndex = 0;
-      totalSizeBytes = 0;
-      localLogEnd = nextSeqNo - 1;
-      commitPoint = nextSeqNo - 1;
+    async preflight(indexName, params) {
+      return trackOp(indexName, () => preflightCluster(readDeps, indexName, params));
+    },
+    async getStats(indexName) {
+      return trackOp(indexName, () => statsCluster(readDeps, indexName));
+    },
+    async getPartitionStats(indexName) {
+      return trackOp(indexName, () => partitionStatsCluster(readDeps, indexName));
+    },
+    async checkpoint(indexName) {
+      return trackOp(indexName, () => engine.checkpoint(indexName));
+    },
+    async getMemoryStats() {
+      return trackOp(null, () => engine.getMemoryStats());
+    },
+    on(event, handler) {
+      engine.on(event, handler);
+    },
+    off(event, handler) {
+      engine.off(event, handler);
+    },
+    async query(indexName, params) {
+      return trackOp(indexName, () => queryCluster(readDeps, indexName, params));
+    },
+    async get(indexName, docId) {
+      return trackOp(indexName, async () => (await readClusterDocuments(readDeps, indexName, [docId])).get(docId));
+    },
+    async getMultiple(indexName, docIds) {
+      return trackOp(indexName, () => readClusterDocuments(readDeps, indexName, docIds));
+    },
+    async has(indexName, docId) {
+      return trackOp(indexName, async () => (await readClusterDocuments(readDeps, indexName, [docId])).has(docId));
     }
   };
 }
 
-// src/distribution/cluster-node/replication-logs.ts
-function replicationLogKey(indexName, partitionId) {
-  return `${indexName}:${partitionId}`;
+// src/distribution/cluster-node/operation-tracker.ts
+function createClusterOperationTracker(config) {
+  let activeOperations = 0;
+  let drainResolve = null;
+  const activeByIndex = /* @__PURE__ */ new Map();
+  const indexDrainResolvers = /* @__PURE__ */ new Map();
+  const transitions = /* @__PURE__ */ new Map();
+  function releaseIndex(indexName) {
+    const remaining = (activeByIndex.get(indexName) ?? 1) - 1;
+    if (remaining > 0) {
+      activeByIndex.set(indexName, remaining);
+      return;
+    }
+    activeByIndex.delete(indexName);
+    for (const resolve of indexDrainResolvers.get(indexName) ?? []) resolve();
+    indexDrainResolvers.delete(indexName);
+  }
+  async function track(indexName, action) {
+    config.guard();
+    if (indexName !== null) config.assertIndex(indexName);
+    activeOperations += 1;
+    let indexCounted = false;
+    try {
+      if (indexName !== null) {
+        const transition2 = transitions.get(indexName);
+        if (transition2 !== void 0) await transition2;
+        config.assertIndex(indexName);
+        activeByIndex.set(indexName, (activeByIndex.get(indexName) ?? 0) + 1);
+        indexCounted = true;
+      }
+      return await action();
+    } finally {
+      if (indexName !== null && indexCounted) releaseIndex(indexName);
+      activeOperations -= 1;
+      if (activeOperations === 0 && drainResolve !== null) {
+        drainResolve();
+        drainResolve = null;
+      }
+    }
+  }
+  async function waitForIndexDrain(indexName) {
+    if ((activeByIndex.get(indexName) ?? 0) === 0) return;
+    await new Promise((resolve) => {
+      let resolvers = indexDrainResolvers.get(indexName);
+      if (resolvers === void 0) {
+        resolvers = /* @__PURE__ */ new Set();
+        indexDrainResolvers.set(indexName, resolvers);
+      }
+      resolvers.add(resolve);
+    });
+  }
+  function transition(indexName, action) {
+    return track(null, async () => {
+      const previous = transitions.get(indexName) ?? Promise.resolve();
+      const run = previous.catch(() => void 0).then(async () => {
+        await waitForIndexDrain(indexName);
+        return action();
+      });
+      const tail = run.then(
+        () => void 0,
+        () => void 0
+      );
+      transitions.set(indexName, tail);
+      try {
+        return await run;
+      } finally {
+        if (transitions.get(indexName) === tail) transitions.delete(indexName);
+      }
+    });
+  }
+  async function drain() {
+    if (activeOperations === 0) return;
+    await new Promise((resolve) => {
+      drainResolve = resolve;
+    });
+  }
+  return { track, transition, drain };
 }
-function getReplicationLog(replicationLogs, indexName, partitionId, replicationConfig) {
-  const key = replicationLogKey(indexName, partitionId);
-  let log = replicationLogs.get(key);
-  if (log === void 0) {
-    log = createReplicationLog(partitionId, { logRetentionBytes: replicationConfig?.logRetentionBytes });
-    replicationLogs.set(key, log);
+
+// src/distribution/cluster-node/primary-partition.ts
+async function preparePrimaryPartition(indexName, partitionId, deps) {
+  const schema = await deps.coordinator.getSchema(indexName);
+  if (schema === null) {
+    return false;
   }
-  return log;
+  const allocation = await deps.coordinator.getAllocation(indexName);
+  if (allocation === null || allocation.assignments.size === 0) {
+    return false;
+  }
+  const existing = deps.engine.listIndexes().find((index) => index.name === indexName);
+  if (existing === void 0) {
+    try {
+      await deps.engine.createIndex(indexName, {
+        schema,
+        partitions: { maxPartitions: allocation.assignments.size }
+      });
+    } catch (error) {
+      if (!(error instanceof NarsilError) || error.code !== ErrorCodes.INDEX_ALREADY_EXISTS) {
+        deps.onError(error);
+        return false;
+      }
+    }
+  } else {
+    const schemaError = validateRestoredSchema(deps.engine, indexName, deps.nodeId, schema);
+    if (schemaError !== null) {
+      deps.onError(schemaError);
+      return false;
+    }
+  }
+  resumeNumberingAboveOwnCopy(indexName, partitionId, allocation.assignments.get(partitionId), deps);
+  return true;
 }
-function seedReplicationLog(replicationLogs, indexName, partitionId, startSeqNo, lastPrimaryTerm = 0, replicationConfig) {
-  replicationLogs.set(
-    replicationLogKey(indexName, partitionId),
-    createReplicationLog(partitionId, {
-      startSeqNo,
-      lastPrimaryTerm,
-      logRetentionBytes: replicationConfig?.logRetentionBytes
-    })
-  );
+function resumeNumberingAboveOwnCopy(indexName, partitionId, assignment, deps) {
+  if (assignment === void 0) {
+    return;
+  }
+  if (deps.replicationLogPosition(indexName, partitionId) > 0) {
+    return;
+  }
+  const floor = Math.max(deps.engine.highestPersistedSeqNoOf(indexName, partitionId), assignment.commitPoint);
+  if (floor <= 0) {
+    return;
+  }
+  deps.seedReplicationLog(indexName, partitionId, floor + 1, assignment.primaryTerm);
 }
 var CONTROLLER_MESSAGE_TYPES = /* @__PURE__ */ new Set([
   ReplicationMessageTypes.INSYNC_ADD,
@@ -11041,10 +11183,25 @@ async function createClusterNode(config) {
   const nodeId = config.nodeId ?? generateId();
   const roles = config.roles ?? ["data", "coordinator", "controller"];
   const capacity = config.capacity ?? DEFAULT_CAPACITY;
-  const engine = await createClusterLocalEngine(config.engine);
   const bootstrapSyncState = createBootstrapSyncState();
   const snapshotSyncHandlerState = createSnapshotSyncHandlerState();
   const replicationLogs = /* @__PURE__ */ new Map();
+  let localEngine = null;
+  const engine = await createClusterLocalEngine(config.engine, {
+    async onIndexOpen(indexName) {
+      if (localEngine === null) return;
+      await seedReopenedPrimaryLogs({
+        indexName,
+        nodeId,
+        engine: localEngine,
+        coordinator: config.coordinator,
+        replicationLogs,
+        replicationConfig: config.replication
+      });
+    },
+    onIndexClose: (indexName) => deleteIndexReplicationLogs(replicationLogs, indexName)
+  });
+  localEngine = engine;
   function replicationLogKey2(indexName, partitionId) {
     return replicationLogKey(indexName, partitionId);
   }
@@ -11094,8 +11251,6 @@ async function createClusterNode(config) {
   let unregisterNotReadyHandler = null;
   let serving = false;
   let isShutdown = false;
-  let activeOps = 0;
-  let drainResolve = null;
   const bootstrapSyncDeps = {
     engine,
     coordinator: config.coordinator,
@@ -11168,22 +11323,14 @@ async function createClusterNode(config) {
       throw new NarsilError(ErrorCodes.NODE_NOT_JOINED, `Cluster node '${nodeId}' has been shut down`, { nodeId });
     }
   }
-  async function trackOp(indexName, fn) {
-    guardShutdown();
-    if (indexName !== null && orphanedIndexes.has(indexName)) {
-      throw orphanedIndexError(nodeId, indexName);
-    }
-    activeOps++;
-    try {
-      return await fn();
-    } finally {
-      activeOps--;
-      if (activeOps === 0 && drainResolve !== null) {
-        drainResolve();
-        drainResolve = null;
-      }
+  const operationTracker = createClusterOperationTracker({
+    guard: guardShutdown,
+    assertIndex(indexName) {
+      if (orphanedIndexes.has(indexName)) throw orphanedIndexError(nodeId, indexName);
     }
-  }
+  });
+  const trackOp = operationTracker.track;
+  const transitionIndex = operationTracker.transition;
   const readDeps = { config, nodeId, engine, resolveNodeTargets: resolveNodeTargets3 };
   const cluster = createClusterNamespace({
     nodeId,
@@ -11202,13 +11349,17 @@ async function createClusterNode(config) {
     get roles() {
       return roles;
     },
+    open: (indexName) => trackOp(indexName, () => engine.open(indexName)),
+    close: (indexName) => transitionIndex(indexName, () => engine.close(indexName)),
     ...createClusterNodeOperations({
       trackOp,
+      transitionIndex,
       readDeps,
       writeDeps,
       engine,
       coordinator: config.coordinator,
       forgetIndex: (indexName) => {
+        deleteIndexReplicationLogs(replicationLogs, indexName);
         if (engine.listIndexes().every((index) => index.name !== indexName)) {
           orphanedIndexes.delete(indexName);
         }
@@ -11258,11 +11409,7 @@ async function createClusterNode(config) {
       }
       isShutdown = true;
       serving = false;
-      if (activeOps > 0) {
-        await new Promise((resolve) => {
-          drainResolve = resolve;
-        });
-      }
+      await operationTracker.drain();
       if (unregisterHandler !== null) {
         unregisterHandler();
         unregisterHandler = null;
@@ -11285,14 +11432,20 @@ async function createClusterNode(config) {
     if (partitionId === null) {
       return fallback;
     }
-    const allocation = await config.coordinator.getAllocation(indexName);
-    const assignment = allocation?.assignments.get(partitionId);
-    const log = getReplicationLog2(indexName, partitionId);
-    return {
-      partitionId,
-      primaryTerm: assignment?.primaryTerm ?? fallback.primaryTerm,
-      lastSeqNo: log.newestSeqNo ?? 0
-    };
+    const localIndex = engine.listIndexes().find((index) => index.name === indexName);
+    const release = localIndex !== void 0 ? await engine.acquireIndexForReplication(indexName) : null;
+    try {
+      const allocation = await config.coordinator.getAllocation(indexName);
+      const assignment = allocation?.assignments.get(partitionId);
+      const log = getReplicationLog2(indexName, partitionId);
+      return {
+        partitionId,
+        primaryTerm: assignment?.primaryTerm ?? fallback.primaryTerm,
+        lastSeqNo: log.newestSeqNo ?? 0
+      };
+    } finally {
+      release?.();
+    }
   }
 }
 
@@ -11306,6 +11459,12 @@ function unsupported(operation) {
 }
 function clusterNodeEngine(node, options) {
   return {
+    open(indexName) {
+      return node.open(indexName);
+    },
+    close(indexName) {
+      return node.close(indexName);
+    },
     async createIndex(name, config) {
       return node.createIndex(name, config, options?.createIndex);
     },