@delali/narsil 0.1.15 → 0.2.0

package/dist/distribution.mjs

@@ -1,12 +1,13 @@
 export { createInMemoryCoordinator } from './chunk-RQLXC2YS.mjs';
-import './chunk-WISGW24C.mjs';
-import { ReplicationMessageTypes, ClusterMessageTypes, DEFAULT_TRANSPORT_CONFIG, TransportError, TransportErrorCodes, MAX_MESSAGE_SIZE_BYTES, createEngineCore, createNarsilFromCore, QueryMessageTypes, applyIndexEntry, applyDeleteEntry, validateEntryPayload, createAckMessage, validateReplicationEntry, MAX_PARTITION_COUNT, MAX_INDEX_NAME_LENGTH, validateIndexName, computeEntryChecksum, createInsyncConfirmMessage, createEntryMessage, getIndexMetadata, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, putIndexMetadata, createForwardMessage } from './chunk-MEW7HD75.mjs';
-import { deserializePayloadV2, createPartitionIndex, getLanguage, fnv1a, mergePartitionStats, MAX_NESTING_DEPTH } from './chunk-HMO6OMZ3.mjs';
+import './chunk-AUMKFYTG.mjs';
+import { ReplicationMessageTypes, ClusterMessageTypes, DEFAULT_TRANSPORT_CONFIG, TransportError, TransportErrorCodes, MAX_MESSAGE_SIZE_BYTES, createEngineCore, createNarsilFromCore, QueryMessageTypes, applyIndexEntry, applyDeleteEntry, validateEntryPayload, createAckMessage, validateReplicationEntry, MAX_PARTITION_COUNT, MAX_INDEX_NAME_LENGTH, validateIndexName, computeEntryChecksum, createInsyncConfirmMessage, createEntryMessage, getIndexMetadata, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, putIndexMetadata, createForwardMessage } from './chunk-XAKNSWIK.mjs';
+import { deserializePayloadV2, createPartitionIndex, getLanguage, fnv1a, mergePartitionStats, MAX_NESTING_DEPTH } from './chunk-S6IAXOBA.mjs';
+import './chunk-TGP5M5R7.mjs';
 import './chunk-S7RJJMHI.mjs';
 import { crc32 } from './chunk-KMMJMDUA.mjs';
-import './chunk-TW6BXTOL.mjs';
-import { ErrorCodes, NarsilError } from './chunk-ALB35PRQ.mjs';
-import { generateId } from './chunk-HRABJLPB.mjs';
+import './chunk-U2BKYEC7.mjs';
+import { ErrorCodes, NarsilError } from './chunk-M2EDG55Y.mjs';
+import { generateId } from './chunk-BKAI2WXI.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 // src/distribution/cluster/controller/types.ts
@@ -1474,6 +1475,90 @@ function createDataNodeLifecycle(config) {
   return handle;
 }
 
+// src/distribution/query/cursor.ts
+var MAX_CURSOR_LENGTH = 4096;
+var MAX_CURSOR_DOC_ID_LENGTH = 512;
+function truncateCursorForError(encoded) {
+  if (encoded.length > 100) {
+    return `${encoded.slice(0, 100)}...`;
+  }
+  return encoded;
+}
+function encodeDistributedCursor(score, docId) {
+  const json = JSON.stringify({ s: score, d: docId });
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(json).toString("base64");
+  }
+  return btoa(json);
+}
+function decodeDistributedCursor(encoded) {
+  if (encoded.length > MAX_CURSOR_LENGTH) {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_CURSOR,
+      `Distributed cursor exceeds maximum length of ${MAX_CURSOR_LENGTH}`,
+      { cursor: truncateCursorForError(encoded) }
+    );
+  }
+  let json;
+  try {
+    if (typeof Buffer !== "undefined") {
+      json = Buffer.from(encoded, "base64").toString("utf-8");
+    } else {
+      json = atob(encoded);
+    }
+  } catch {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_CURSOR,
+      "Failed to decode distributed cursor: invalid base64 encoding",
+      { cursor: truncateCursorForError(encoded) }
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    throw new NarsilError(ErrorCodes.SEARCH_INVALID_CURSOR, "Failed to decode distributed cursor: invalid JSON", {
+      cursor: truncateCursorForError(encoded)
+    });
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_CURSOR,
+      'Invalid distributed cursor structure: expected an object with "s" and "d" fields',
+      { cursor: truncateCursorForError(encoded) }
+    );
+  }
+  const record = parsed;
+  const { s, d } = record;
+  if (typeof s !== "number" || !Number.isFinite(s)) {
+    throw new NarsilError(ErrorCodes.SEARCH_INVALID_CURSOR, 'Invalid distributed cursor: "s" must be a finite number', {
+      cursor: truncateCursorForError(encoded)
+    });
+  }
+  if (typeof d !== "string" || d.length === 0) {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_CURSOR,
+      'Invalid distributed cursor: "d" must be a non-empty string',
+      { cursor: truncateCursorForError(encoded) }
+    );
+  }
+  if (d.length > MAX_CURSOR_DOC_ID_LENGTH) {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_CURSOR,
+      `Invalid distributed cursor: "d" exceeds maximum length of ${MAX_CURSOR_DOC_ID_LENGTH}`,
+      { cursor: truncateCursorForError(encoded) }
+    );
+  }
+  if (d.includes("\0")) {
+    throw new NarsilError(
+      ErrorCodes.SEARCH_INVALID_CURSOR,
+      'Invalid distributed cursor: "d" must not contain null bytes',
+      { cursor: truncateCursorForError(encoded) }
+    );
+  }
+  return { s, d };
+}
+
 // src/distribution/query/validators/common.ts
 var MAX_PARTITION_IDS = MAX_PARTITION_COUNT;
 var MAX_TERM_LENGTH = 1024;
@@ -1682,90 +1767,6 @@ function validateFetchResultPayload(decoded) {
   return decoded;
 }
 
-// src/distribution/query/cursor.ts
-var MAX_CURSOR_LENGTH = 4096;
-var MAX_CURSOR_DOC_ID_LENGTH = 512;
-function truncateCursorForError(encoded) {
-  if (encoded.length > 100) {
-    return `${encoded.slice(0, 100)}...`;
-  }
-  return encoded;
-}
-function encodeDistributedCursor(score, docId) {
-  const json = JSON.stringify({ s: score, d: docId });
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(json).toString("base64");
-  }
-  return btoa(json);
-}
-function decodeDistributedCursor(encoded) {
-  if (encoded.length > MAX_CURSOR_LENGTH) {
-    throw new NarsilError(
-      ErrorCodes.SEARCH_INVALID_CURSOR,
-      `Distributed cursor exceeds maximum length of ${MAX_CURSOR_LENGTH}`,
-      { cursor: truncateCursorForError(encoded) }
-    );
-  }
-  let json;
-  try {
-    if (typeof Buffer !== "undefined") {
-      json = Buffer.from(encoded, "base64").toString("utf-8");
-    } else {
-      json = atob(encoded);
-    }
-  } catch {
-    throw new NarsilError(
-      ErrorCodes.SEARCH_INVALID_CURSOR,
-      "Failed to decode distributed cursor: invalid base64 encoding",
-      { cursor: truncateCursorForError(encoded) }
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(json);
-  } catch {
-    throw new NarsilError(ErrorCodes.SEARCH_INVALID_CURSOR, "Failed to decode distributed cursor: invalid JSON", {
-      cursor: truncateCursorForError(encoded)
-    });
-  }
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new NarsilError(
-      ErrorCodes.SEARCH_INVALID_CURSOR,
-      'Invalid distributed cursor structure: expected an object with "s" and "d" fields',
-      { cursor: truncateCursorForError(encoded) }
-    );
-  }
-  const record = parsed;
-  const { s, d } = record;
-  if (typeof s !== "number" || !Number.isFinite(s)) {
-    throw new NarsilError(ErrorCodes.SEARCH_INVALID_CURSOR, 'Invalid distributed cursor: "s" must be a finite number', {
-      cursor: truncateCursorForError(encoded)
-    });
-  }
-  if (typeof d !== "string" || d.length === 0) {
-    throw new NarsilError(
-      ErrorCodes.SEARCH_INVALID_CURSOR,
-      'Invalid distributed cursor: "d" must be a non-empty string',
-      { cursor: truncateCursorForError(encoded) }
-    );
-  }
-  if (d.length > MAX_CURSOR_DOC_ID_LENGTH) {
-    throw new NarsilError(
-      ErrorCodes.SEARCH_INVALID_CURSOR,
-      `Invalid distributed cursor: "d" exceeds maximum length of ${MAX_CURSOR_DOC_ID_LENGTH}`,
-      { cursor: truncateCursorForError(encoded) }
-    );
-  }
-  if (d.includes("\0")) {
-    throw new NarsilError(
-      ErrorCodes.SEARCH_INVALID_CURSOR,
-      'Invalid distributed cursor: "d" must not contain null bytes',
-      { cursor: truncateCursorForError(encoded) }
-    );
-  }
-  return { s, d };
-}
-
 // src/distribution/query/validators/filters.ts
 var COMPARISON_NUMERIC_OPS = ["gt", "lt", "gte", "lte"];
 var COMPARISON_EQ_OPS = ["eq", "ne"];
@@ -2493,6 +2494,8 @@ function createStatsMessage(payload, sourceId) {
     payload: encode(payload)
   };
 }
+
+// src/distribution/query/fan-out.ts
 async function collectDistributedStats(indexName, params, nodeToPartitions, deps, config) {
   const terms = params.term !== null ? params.term.split(/\s+/).filter((t) => t.length > 0) : [];
   const statsPromises = [];
@@ -2849,8 +2852,8 @@ function mergeDistributedFacets(allFacets, maxBuckets = DEFAULT_MAX_FACET_BUCKET
 }
 
 // src/distribution/query/selection.ts
-function hashBasedSelector(candidates, partitionId) {
-  return candidates[partitionId % candidates.length];
+function randomSelector(candidates, _partitionId) {
+  return candidates[Math.floor(Math.random() * candidates.length)];
 }
 function collectActiveCandidates(assignment) {
   if (assignment.state !== "ACTIVE") {
@@ -2868,7 +2871,7 @@ function collectActiveCandidates(assignment) {
   candidates.sort();
   return candidates;
 }
-function selectReplica(assignment, localNodeId, selector = hashBasedSelector, partitionId = 0) {
+function selectReplica(assignment, localNodeId, selector = randomSelector, partitionId = 0) {
   const candidates = collectActiveCandidates(assignment);
   if (candidates.length === 0) {
     return null;
@@ -2878,7 +2881,7 @@ function selectReplica(assignment, localNodeId, selector = hashBasedSelector, pa
   }
   return selector(candidates, partitionId);
 }
-function selectReplicasForQuery(allocationTable, localNodeId, selector = hashBasedSelector) {
+function selectReplicasForQuery(allocationTable, localNodeId, selector = randomSelector) {
   const nodeToPartitions = /* @__PURE__ */ new Map();
   const unavailablePartitions = [];
   for (const [partitionId, assignment] of allocationTable.assignments) {
@@ -2936,7 +2939,7 @@ async function distributedQuery(indexName, params, deps, config, selector) {
       coverage: { totalPartitions: 0, queriedPartitions: 0, timedOutPartitions: 0, failedPartitions: 0 }
     };
   }
-  const routing = selectReplicasForQuery(allocationTable, deps.sourceNodeId, hashBasedSelector);
+  const routing = selectReplicasForQuery(allocationTable, deps.sourceNodeId, randomSelector);
   const totalPartitions = allocationTable.assignments.size;
   if (routing.unavailablePartitions.length > 0 && !resolvedConfig.allowPartialResults) {
     throw new NarsilError("QUERY_NO_ACTIVE_REPLICA", "No active replica for one or more partitions", {
@@ -3100,242 +3103,53 @@ function worstCaseCoverage(a, b) {
   };
 }
 
-// src/distribution/replication/types.ts
-var DEFAULT_LOG_RETENTION_BYTES = 268435456;
-
-// src/distribution/replication/log.ts
-var ENTRY_FIXED_OVERHEAD_BYTES = 40;
-function estimateEntrySize(entry) {
-  return ENTRY_FIXED_OVERHEAD_BYTES + entry.indexName.length + entry.documentId.length + (entry.document?.byteLength ?? 0);
+// src/distribution/cluster-node/bootstrap-cleanup.ts
+async function cleanupRemovedPartition(indexName, partitionId, deps) {
+  try {
+    const existing = deps.engine.listIndexes().find((idx) => idx.name === indexName);
+    if (existing === void 0) {
+      return;
+    }
+    if (await nodeHasOtherPartitions(indexName, partitionId, deps)) {
+      return;
+    }
+    await deps.engine.dropIndex(indexName);
+  } catch (err) {
+    if (deps.onError === void 0) {
+      return;
+    }
+    if (err instanceof NarsilError && err.code === ErrorCodes.INDEX_NOT_FOUND) {
+      return;
+    }
+    const cause = err instanceof Error ? err.message : String(err);
+    deps.onError(
+      new NarsilError(
+        ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED,
+        `failed to drop local index '${indexName}' after partition removal: ${cause}`,
+        { indexName, partitionId, cause }
+      )
+    );
+  }
 }
-var computeChecksum = computeEntryChecksum;
-function createReplicationLog(partitionId, config) {
-  const retentionBytes = config?.logRetentionBytes ?? DEFAULT_LOG_RETENTION_BYTES;
-  let nextSeqNo = config?.startSeqNo ?? 1;
-  let committedSeqNo = nextSeqNo - 1;
-  let committedPrimaryTerm = config?.lastPrimaryTerm ?? 0;
-  let entries = [];
-  let headIndex = 0;
-  let totalSizeBytes = 0;
-  function liveCount() {
-    return entries.length - headIndex;
+async function nodeHasOtherPartitions(indexName, removedPartitionId, deps) {
+  let allocation;
+  try {
+    allocation = await deps.coordinator.getAllocation(indexName);
+  } catch (_) {
+    return true;
   }
-  function compact() {
-    if (headIndex > 0) {
-      entries = entries.slice(headIndex);
-      headIndex = 0;
-    }
+  if (allocation === null) {
+    return false;
   }
-  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;
-      }
+  for (const [partitionId, assignment] of allocation.assignments) {
+    if (partitionId === removedPartitionId) {
+      continue;
     }
-    return low;
-  }
-  function evictOldEntries() {
-    while (liveCount() > 0 && totalSizeBytes > retentionBytes) {
-      totalSizeBytes -= estimateEntrySize(entries[headIndex]);
-      entries[headIndex] = null;
-      headIndex += 1;
+    if (assignment.primary === deps.nodeId) {
+      return true;
     }
-    if (totalSizeBytes < 0) {
-      totalSizeBytes = 0;
-    }
-    if (headIndex >= 256 || headIndex > liveCount()) {
-      compact();
-    }
-  }
-  function storeEntry(entry) {
-    entries.push(entry);
-    if (entry.seqNo >= committedSeqNo) {
-      committedSeqNo = entry.seqNo;
-      committedPrimaryTerm = 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) {
-      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_INVALID,
-          `Invalid checksum for replication entry ${entry.seqNo}`,
-          { seqNo: entry.seqNo, partitionId }
-        );
-      }
-      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 committedSeqNo() {
-      return committedSeqNo;
-    },
-    get committedPrimaryTerm() {
-      return committedPrimaryTerm;
-    },
-    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;
-      committedSeqNo = nextSeqNo - 1;
-    }
-  };
-}
-
-// src/distribution/cluster-node/bootstrap-cleanup.ts
-async function cleanupRemovedPartition(indexName, partitionId, deps) {
-  try {
-    const existing = deps.engine.listIndexes().find((idx) => idx.name === indexName);
-    if (existing === void 0) {
-      return;
-    }
-    if (await nodeHasOtherPartitions(indexName, partitionId, deps)) {
-      return;
-    }
-    await deps.engine.dropIndex(indexName);
-  } catch (err) {
-    if (deps.onError === void 0) {
-      return;
-    }
-    if (err instanceof NarsilError && err.code === ErrorCodes.INDEX_NOT_FOUND) {
-      return;
-    }
-    const cause = err instanceof Error ? err.message : String(err);
-    deps.onError(
-      new NarsilError(
-        ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED,
-        `failed to drop local index '${indexName}' after partition removal: ${cause}`,
-        { indexName, partitionId, cause }
-      )
-    );
-  }
-}
-async function nodeHasOtherPartitions(indexName, removedPartitionId, deps) {
-  let allocation;
-  try {
-    allocation = await deps.coordinator.getAllocation(indexName);
-  } catch (_) {
-    return true;
-  }
-  if (allocation === null) {
-    return false;
-  }
-  for (const [partitionId, assignment] of allocation.assignments) {
-    if (partitionId === removedPartitionId) {
-      continue;
-    }
-    if (assignment.primary === deps.nodeId) {
-      return true;
-    }
-    if (assignment.replicas.includes(deps.nodeId)) {
-      return true;
+    if (assignment.replicas.includes(deps.nodeId)) {
+      return true;
     }
   }
   return false;
@@ -3662,6 +3476,8 @@ function toStreamFailure(err, defaultCode, defaultMessage) {
     details: { cause: message }
   };
 }
+
+// src/distribution/cluster-node/bootstrap-fetch.ts
 var CAPACITY_EXHAUSTED_BACKOFF_BASE_MS = 100;
 var CAPACITY_EXHAUSTED_BACKOFF_MAX_MS = 500;
 var RETRY_ANY_TARGET_CODES = /* @__PURE__ */ new Set([
@@ -3963,10 +3779,10 @@ function validateArguments(indexName, partitionId, primaryNodeId) {
   }
   return null;
 }
-async function resolveTransportTargets(indexName, primaryNodeId, resolveNodeTargets2) {
+async function resolveTransportTargets(indexName, primaryNodeId, resolveNodeTargets3) {
   let targets;
   try {
-    targets = await resolveNodeTargets2(primaryNodeId);
+    targets = await resolveNodeTargets3(primaryNodeId);
   } catch (err) {
     const cause = err instanceof Error ? err.message : String(err);
     return new NarsilError(ErrorCodes.SNAPSHOT_SYNC_NO_TARGETS, `resolveNodeTargets failed: ${cause}`, {
@@ -4128,7 +3944,7 @@ async function dropExistingIndex(engine, indexName, primaryNodeId) {
   }
 }
 
-// src/distribution/cluster-node/bootstrap-sync.ts
+// src/distribution/cluster-node/bootstrap-sync/state.ts
 var DEFAULT_BOOTSTRAP_SYNC_DEADLINE_MS = 6e5;
 function createBootstrapSyncState() {
   return {
@@ -4160,40 +3976,6 @@ function clearBootstrapSyncIndex(state, indexName, partitionId) {
 function hasCompletedBootstrapSync(state, indexName, partitionId) {
   return state.completed.has(entryKey(indexName, partitionId));
 }
-async function runBootstrapSync(state, indexName, partitionId, primaryNodeId, deps) {
-  const validationError = validateArguments(indexName, partitionId, primaryNodeId);
-  if (validationError !== null) {
-    surfaceError(deps, indexName, primaryNodeId, validationError);
-    return false;
-  }
-  const key = entryKey(indexName, partitionId);
-  if (state.completed.has(key)) {
-    return true;
-  }
-  const existing = state.inFlight.get(key);
-  if (existing !== void 0) {
-    const result = await Promise.race([existing.promise, existing.abortPromise]);
-    if (result === ABORT_SENTINEL) {
-      return false;
-    }
-    return result;
-  }
-  const entry = createEntry(state, indexName, partitionId, key);
-  entry.promise = executeBootstrapSync(state, entry, indexName, partitionId, primaryNodeId, deps).finally(() => {
-    const current = state.inFlight.get(key);
-    if (current === entry) {
-      state.inFlight.delete(key);
-    }
-    if (!state.completed.has(key) && !state.inFlight.has(key)) {
-      const currentGen = state.generations.get(key);
-      if (currentGen !== void 0 && currentGen !== entry.generation) {
-        state.generations.delete(key);
-      }
-    }
-  });
-  state.inFlight.set(key, entry);
-  return entry.promise;
-}
 function createEntry(state, indexName, partitionId, key) {
   const startGeneration = state.generations.get(key) ?? 0;
   let abortResolve = () => {
@@ -4211,401 +3993,100 @@ function createEntry(state, indexName, partitionId, key) {
     abortPromise
   };
 }
-async function executeBootstrapSync(state, entry, indexName, partitionId, primaryNodeId, deps) {
-  const deadlineMs = deps.deadlineMs ?? DEFAULT_BOOTSTRAP_SYNC_DEADLINE_MS;
-  const deadline = Date.now() + deadlineMs;
-  const key = entryKey(indexName, partitionId);
-  const abortCheck = () => {
-    const currentGeneration = state.generations.get(key) ?? 0;
-    if (currentGeneration !== entry.generation) {
-      entry.aborted = true;
-    }
-    return entry.aborted;
-  };
-  if (hasLiveBootstrapSyncDeps(deps)) {
-    return executeLiveBootstrapSync(
-      state,
-      entry,
-      indexName,
-      partitionId,
-      primaryNodeId,
-      deps,
-      deadlineMs,
-      deadline,
-      abortCheck
-    );
-  }
-  const schemaResult = await fetchSchemaAndPrepare(entry, indexName, primaryNodeId, deps);
-  if (schemaResult === "aborted") {
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
-  }
-  if (schemaResult === null) {
+function anotherBootstrapOwnsKey(state, key, self) {
+  const current = state.inFlight.get(key);
+  if (current === void 0) {
     return false;
   }
-  if (abortCheck()) {
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
-  }
-  if (Date.now() >= deadline) {
-    surfaceError(
-      deps,
-      indexName,
-      primaryNodeId,
-      new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TIMEOUT, "bootstrap sync exceeded deadline before fetching snapshot", {
-        indexName,
-        deadlineMs
-      })
-    );
-    return false;
-  }
-  const targetsResult = await resolveTransportTargets(indexName, primaryNodeId, deps.resolveNodeTargets);
-  if (targetsResult instanceof NarsilError) {
-    surfaceError(deps, indexName, primaryNodeId, targetsResult);
-    return false;
-  }
-  const fetchDeps = { transport: deps.transport, sourceNodeId: deps.sourceNodeId };
-  const fetchResult = await fetchSnapshotFromAnyTarget(
-    indexName,
-    primaryNodeId,
-    targetsResult,
-    deadline,
-    fetchDeps,
-    abortCheck,
-    partitionId
-  );
-  if (!fetchResult.ok) {
-    if (fetchResult.code === ErrorCodes.SNAPSHOT_SYNC_ABORTED) {
-      surfaceAborted(deps, indexName, primaryNodeId);
-      return false;
-    }
-    surfaceError(
-      deps,
-      indexName,
-      primaryNodeId,
-      new NarsilError(fetchResult.code, fetchResult.message, {
-        indexName,
-        primaryNodeId,
-        ...fetchResult.details
-      })
-    );
-    return false;
-  }
-  if (abortCheck()) {
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
-  }
-  const restoreSucceeded = await applyRestore(
-    state,
-    entry,
-    indexName,
-    primaryNodeId,
-    fetchResult.bytes,
-    schemaResult,
-    deadline,
-    deps
-  );
-  if (!restoreSucceeded) {
-    return false;
-  }
-  if (abortCheck()) {
-    if (!anotherBootstrapOwnsKey(state, key, entry)) {
-      await dropRestoredIndexQuietly(deps.engine, indexName, deps);
-    }
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
-  }
-  deps.onSnapshotApplied?.(indexName, partitionId, fetchResult.header);
-  state.completed.add(key);
-  return true;
-}
-async function resolveLivePartitionCount(coordinator, indexName, partitionId, primaryNodeId, abortPromise) {
-  try {
-    const winner = await Promise.race([coordinator.getAllocation(indexName), abortPromise]);
-    if (winner === ABORT_SENTINEL) {
-      return "aborted";
-    }
-    const allocation = winner;
-    if (allocation === null) {
-      return {
-        error: new NarsilError(
-          ErrorCodes.SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE,
-          `coordinator has no allocation for index '${indexName}'`,
-          { indexName, primaryNodeId }
-        )
-      };
-    }
-    const assignment = allocation.assignments.get(partitionId);
-    if (assignment === void 0) {
-      return {
-        error: new NarsilError(
-          ErrorCodes.SNAPSHOT_SYNC_NOT_ASSIGNED,
-          `No assignment exists for partition ${partitionId} of index '${indexName}'`,
-          { indexName, partitionId, primaryNodeId }
-        )
-      };
-    }
-    if (assignment.primary !== primaryNodeId) {
-      return {
-        error: new NarsilError(
-          ErrorCodes.SNAPSHOT_SYNC_NOT_ASSIGNED,
-          `Partition ${partitionId} of index '${indexName}' is no longer primary on '${primaryNodeId}'`,
-          { indexName, partitionId, primaryNodeId, currentPrimary: assignment.primary }
-        )
-      };
-    }
-    return { partitionCount: allocation.assignments.size };
-  } catch (err) {
-    const cause = err instanceof Error ? err.message : String(err);
-    return {
-      error: new NarsilError(
-        ErrorCodes.SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE,
-        `coordinator.getAllocation failed: ${cause}`,
-        {
-          indexName,
-          partitionId,
-          primaryNodeId,
-          cause
-        }
-      )
-    };
-  }
+  return current !== self;
 }
-async function executeLiveBootstrapSync(state, entry, indexName, partitionId, primaryNodeId, deps, deadlineMs, deadline, abortCheck) {
-  const schemaResult = await loadCoordinatorSchema(deps.coordinator, indexName, primaryNodeId, entry.abortPromise);
-  if (schemaResult === "aborted") {
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
-  }
-  if ("error" in schemaResult) {
-    surfaceError(deps, indexName, primaryNodeId, schemaResult.error);
-    return false;
-  }
-  if (abortCheck()) {
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
-  }
-  const allocationResult = await resolveLivePartitionCount(
-    deps.coordinator,
-    indexName,
-    partitionId,
-    primaryNodeId,
-    entry.abortPromise
-  );
-  if (allocationResult === "aborted") {
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
-  }
-  if ("error" in allocationResult) {
-    surfaceError(deps, indexName, primaryNodeId, allocationResult.error);
-    return false;
-  }
-  if (Date.now() >= deadline) {
-    surfaceError(
-      deps,
-      indexName,
-      primaryNodeId,
-      new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TIMEOUT, "bootstrap sync exceeded deadline before starting live sync", {
-        indexName,
-        deadlineMs
-      })
-    );
-    return false;
-  }
-  const targetsResult = await resolveTransportTargets(indexName, primaryNodeId, deps.resolveNodeTargets);
-  if (targetsResult instanceof NarsilError) {
-    surfaceError(deps, indexName, primaryNodeId, targetsResult);
-    return false;
-  }
-  const syncResult = await syncFromAnyTarget(
-    state,
-    entry,
-    indexName,
-    partitionId,
-    primaryNodeId,
-    targetsResult,
-    schemaResult.schema,
-    allocationResult.partitionCount,
-    deadline,
-    deps,
-    abortCheck
-  );
-  if (!syncResult.ok) {
-    if (syncResult.error.code === ErrorCodes.SNAPSHOT_SYNC_ABORTED) {
-      surfaceAborted(deps, indexName, primaryNodeId);
-      return false;
-    }
-    if (syncResult.error.details.alreadySurfaced !== true) {
-      surfaceError(deps, indexName, primaryNodeId, syncResult.error);
-    }
-    return false;
-  }
-  if (abortCheck()) {
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
-  }
-  if (syncResult.snapshotHeader !== null) {
-    deps.onSnapshotApplied?.(indexName, partitionId, syncResult.snapshotHeader);
+
+// src/distribution/cluster-node/bootstrap-sync/entries.ts
+async function applySyncEntries(indexName, partitionId, entriesPayloads, expectedFirstSeqNo, localPrimaryTerm, deps) {
+  const terminalError = validateSyncEntryBatchTermination(entriesPayloads);
+  if (terminalError !== null) {
+    return { ok: false, error: terminalError };
   }
-  state.completed.add(entryKey(indexName, partitionId));
-  return true;
-}
-async function syncFromAnyTarget(state, entry, indexName, partitionId, primaryNodeId, targets, coordinatorSchema, partitionCount, deadline, deps, abortCheck) {
-  let lastError = new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TRANSPORT_FAILED, "no live sync attempts were made", {
-    indexName,
-    partitionId,
-    primaryNodeId
-  });
-  const attempted = /* @__PURE__ */ new Set();
-  for (const target of targets) {
-    if (attempted.has(target)) {
-      continue;
-    }
-    attempted.add(target);
-    if (abortCheck()) {
-      return {
-        ok: false,
-        error: new NarsilError(ErrorCodes.SNAPSHOT_SYNC_ABORTED, "bootstrap sync aborted before next live target", {
-          indexName,
-          partitionId,
-          primaryNodeId,
-          target
-        })
-      };
-    }
-    if (Date.now() >= deadline) {
-      return {
-        ok: false,
-        error: new NarsilError(
-          ErrorCodes.SNAPSHOT_SYNC_TIMEOUT,
-          "bootstrap sync exceeded deadline while iterating live targets",
-          { indexName, partitionId, primaryNodeId, targets }
-        )
-      };
-    }
-    const attempt = await syncFromTarget(
-      state,
-      entry,
-      indexName,
-      partitionId,
-      target,
-      coordinatorSchema,
-      partitionCount,
-      deadline,
-      deps,
-      abortCheck
-    );
-    if (attempt.ok) {
-      return attempt;
-    }
-    lastError = new NarsilError(attempt.error.code, attempt.error.message, {
-      ...attempt.error.details,
-      target
-    });
-    if (!isTransientFailure(attempt.error.code, attempt.error.details)) {
-      return { ok: false, error: lastError };
+  const log = deps.getReplicationLog(indexName, partitionId);
+  let expectedSeqNo = expectedFirstSeqNo;
+  let entriesApplied = 0;
+  for (const payload of entriesPayloads) {
+    for (const entry of payload.entries) {
+      const entryError = validateSyncEntryForApply(entry, indexName, partitionId, expectedSeqNo, localPrimaryTerm, log);
+      if (entryError !== null) {
+        return { ok: false, error: entryError };
+      }
+      try {
+        await deps.applyReplicationEntry(entry);
+        log.appendCommitted(entry);
+      } catch (err) {
+        const cause = err instanceof Error ? err.message : String(err);
+        return {
+          ok: false,
+          error: new NarsilError(ErrorCodes.REPLICATION_ENTRY_INVALID, `failed to apply sync entry: ${cause}`, {
+            indexName,
+            partitionId,
+            seqNo: entry.seqNo,
+            cause
+          })
+        };
+      }
+      expectedSeqNo = entry.seqNo + 1;
+      entriesApplied += 1;
     }
   }
-  return { ok: false, error: lastError };
-}
-async function syncFromTarget(state, entry, indexName, partitionId, target, coordinatorSchema, partitionCount, deadline, deps, abortCheck) {
-  const logState = readLocalLogState(indexName, partitionId, deps);
-  const requestPayload = {
-    indexName,
-    partitionId,
-    lastSeqNo: logState.lastSeqNo,
-    lastPrimaryTerm: logState.lastPrimaryTerm
-  };
-  const request = {
-    type: ReplicationMessageTypes.SYNC_REQUEST,
-    sourceId: deps.sourceNodeId,
-    requestId: generateId(),
-    payload: encode(requestPayload)
+  return {
+    ok: true,
+    entriesApplied,
+    newSeqNo: expectedSeqNo - 1
   };
-  const frameState = createLiveSyncFrameState(indexName, partitionId);
-  const remainingMs = deadline - Date.now();
-  if (remainingMs <= 0) {
-    return {
-      ok: false,
-      error: new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TIMEOUT, "deadline expired before live sync stream", {
-        indexName,
-        partitionId,
-        target
-      })
-    };
+}
+function validateSyncEntryBatchTermination(entriesPayloads) {
+  if (entriesPayloads.length === 0) {
+    return null;
   }
-  try {
-    const streamWork = deps.transport.stream(target, request, (chunk) => {
-      handleLiveSyncFrame(frameState, chunk);
-    });
-    await withDeadline(streamWork, remainingMs, indexName, "live-sync");
-  } catch (err) {
-    const cause = err instanceof Error ? err.message : String(err);
-    return {
-      ok: false,
-      error: new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TRANSPORT_FAILED, `live sync transport failed: ${cause}`, {
-        indexName,
-        partitionId,
-        target,
-        cause
-      })
-    };
+  for (let i = 0; i < entriesPayloads.length - 1; i += 1) {
+    if (entriesPayloads[i].isLast) {
+      return new NarsilError(ErrorCodes.SNAPSHOT_SYNC_FRAME_INVALID, "sync_entries marked isLast before final batch");
+    }
   }
-  if (frameState.error !== null) {
-    return { ok: false, error: frameState.error };
+  if (!entriesPayloads[entriesPayloads.length - 1].isLast) {
+    return new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_FRAME_INVALID,
+      "live sync stream ended before final sync_entries batch"
+    );
   }
-  if (abortCheck()) {
-    return {
-      ok: false,
-      error: new NarsilError(ErrorCodes.SNAPSHOT_SYNC_ABORTED, "bootstrap sync aborted after live stream", {
-        indexName,
-        partitionId,
-        target
-      })
-    };
+  return null;
+}
+function validateSyncEntryForApply(entry, indexName, partitionId, expectedSeqNo, localPrimaryTerm, log) {
+  if (entry.indexName !== indexName || entry.partitionId !== partitionId) {
+    return new NarsilError(
+      ErrorCodes.REPLICATION_ENTRY_INVALID,
+      "replication entry scope does not match bootstrap target",
+      {
+        expectedIndexName: indexName,
+        expectedPartitionId: partitionId,
+        entryIndexName: entry.indexName,
+        entryPartitionId: entry.partitionId
+      }
+    );
   }
-  if (frameState.sawSnapshotFrame) {
-    return applyLiveSnapshotSync(
-      state,
-      entry,
-      indexName,
-      partitionId,
-      target,
-      frameState,
-      coordinatorSchema,
-      partitionCount,
-      deadline,
-      deps
+  if (entry.seqNo !== expectedSeqNo) {
+    return new NarsilError(
+      ErrorCodes.REPLICATION_ENTRY_INVALID,
+      `Out-of-order sync entry ${entry.seqNo}; expected ${expectedSeqNo}`,
+      { indexName, partitionId, seqNo: entry.seqNo, expectedSeqNo }
     );
   }
-  if (frameState.syncEntries.length > 0) {
-    return applyLiveIncrementalSync(
-      indexName,
-      partitionId,
-      target,
-      frameState.syncEntries,
-      logState.lastSeqNo + 1,
-      logState.lastPrimaryTerm,
-      coordinatorSchema,
-      partitionCount,
-      deps
+  const validation = validateReplicationEntry(entry, localPrimaryTerm, log);
+  if (!validation.valid) {
+    return new NarsilError(
+      validation.error ?? ErrorCodes.REPLICATION_ENTRY_INVALID,
+      `Invalid sync entry ${entry.seqNo}`,
+      { indexName, partitionId, seqNo: entry.seqNo }
     );
   }
-  return {
-    ok: false,
-    error: new NarsilError(ErrorCodes.SNAPSHOT_SYNC_CHUNK_MISSING, "live sync stream ended without sync frames", {
-      indexName,
-      partitionId,
-      target
-    })
-  };
-}
-function readLocalLogState(indexName, partitionId, deps) {
-  const log = deps.getReplicationLog(indexName, partitionId);
-  const lastSeqNo = log.committedSeqNo;
-  const lastPrimaryTerm = log.committedPrimaryTerm;
-  const newestEntry = log.getEntry(lastSeqNo);
-  return { lastSeqNo, lastPrimaryTerm: newestEntry?.primaryTerm ?? lastPrimaryTerm };
+  return null;
 }
 function createLiveSyncFrameState(indexName, partitionId) {
   return {
@@ -4679,6 +4160,11 @@ function decodeSyncEntriesRecord(record) {
   }
   return { entries, isLast: record.isLast };
 }
+function streamFailureToError(failure) {
+  return new NarsilError(failure.code, failure.message, failure.details);
+}
+
+// src/distribution/cluster-node/bootstrap-sync/apply.ts
 async function applyLiveIncrementalSync(indexName, partitionId, target, entriesPayloads, expectedFirstSeqNo, localPrimaryTerm, coordinatorSchema, partitionCount, deps) {
   const ensureResult = await ensureLocalIndexForIncremental(indexName, target, coordinatorSchema, partitionCount, deps);
   if (ensureResult instanceof NarsilError) {
@@ -4838,136 +4324,334 @@ async function ensureLocalIndexForIncremental(indexName, primaryNodeId, coordina
     const cause = err instanceof Error ? err.message : String(err);
     return new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, `engine.createIndex failed: ${cause}`, {
       indexName,
-      primaryNodeId,
-      cause
-    });
+      primaryNodeId,
+      cause
+    });
+  }
+  return { created: true };
+}
+function validateLocalSchema(engine, indexName, primaryNodeId, coordinatorSchema) {
+  const schemaError = validateRestoredSchema(engine, indexName, primaryNodeId, coordinatorSchema);
+  if (schemaError !== null) {
+    return schemaError;
+  }
+  return { created: false };
+}
+function validateLocalPartitionCount(engine, indexName, primaryNodeId, partitionCount) {
+  let localPartitionCount;
+  try {
+    localPartitionCount = engine.getStats(indexName).partitionCount;
+  } catch (err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    return new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED,
+      `failed to read local partition count for '${indexName}': ${cause}`,
+      { indexName, primaryNodeId, cause }
+    );
+  }
+  if (localPartitionCount !== partitionCount) {
+    return new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED,
+      `local partition count ${localPartitionCount} disagrees with coordinator partition count ${partitionCount}`,
+      { indexName, primaryNodeId, localPartitionCount, partitionCount }
+    );
+  }
+  return { created: false };
+}
+
+// src/distribution/cluster-node/bootstrap-sync/targets.ts
+function readLocalLogState(indexName, partitionId, deps) {
+  const log = deps.getReplicationLog(indexName, partitionId);
+  const lastSeqNo = log.committedSeqNo;
+  const lastPrimaryTerm = log.committedPrimaryTerm;
+  const newestEntry = log.getEntry(lastSeqNo);
+  return { lastSeqNo, lastPrimaryTerm: newestEntry?.primaryTerm ?? lastPrimaryTerm };
+}
+async function syncFromAnyTarget(state, entry, indexName, partitionId, primaryNodeId, targets, coordinatorSchema, partitionCount, deadline, deps, abortCheck) {
+  let lastError = new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TRANSPORT_FAILED, "no live sync attempts were made", {
+    indexName,
+    partitionId,
+    primaryNodeId
+  });
+  const attempted = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    if (attempted.has(target)) {
+      continue;
+    }
+    attempted.add(target);
+    if (abortCheck()) {
+      return {
+        ok: false,
+        error: new NarsilError(ErrorCodes.SNAPSHOT_SYNC_ABORTED, "bootstrap sync aborted before next live target", {
+          indexName,
+          partitionId,
+          primaryNodeId,
+          target
+        })
+      };
+    }
+    if (Date.now() >= deadline) {
+      return {
+        ok: false,
+        error: new NarsilError(
+          ErrorCodes.SNAPSHOT_SYNC_TIMEOUT,
+          "bootstrap sync exceeded deadline while iterating live targets",
+          { indexName, partitionId, primaryNodeId, targets }
+        )
+      };
+    }
+    const attempt = await syncFromTarget(
+      state,
+      entry,
+      indexName,
+      partitionId,
+      target,
+      coordinatorSchema,
+      partitionCount,
+      deadline,
+      deps,
+      abortCheck
+    );
+    if (attempt.ok) {
+      return attempt;
+    }
+    lastError = new NarsilError(attempt.error.code, attempt.error.message, {
+      ...attempt.error.details,
+      target
+    });
+    if (!isTransientFailure(attempt.error.code, attempt.error.details)) {
+      return { ok: false, error: lastError };
+    }
+  }
+  return { ok: false, error: lastError };
+}
+async function syncFromTarget(state, entry, indexName, partitionId, target, coordinatorSchema, partitionCount, deadline, deps, abortCheck) {
+  const logState = readLocalLogState(indexName, partitionId, deps);
+  const requestPayload = {
+    indexName,
+    partitionId,
+    lastSeqNo: logState.lastSeqNo,
+    lastPrimaryTerm: logState.lastPrimaryTerm
+  };
+  const request = {
+    type: ReplicationMessageTypes.SYNC_REQUEST,
+    sourceId: deps.sourceNodeId,
+    requestId: generateId(),
+    payload: encode(requestPayload)
+  };
+  const frameState = createLiveSyncFrameState(indexName, partitionId);
+  const remainingMs = deadline - Date.now();
+  if (remainingMs <= 0) {
+    return {
+      ok: false,
+      error: new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TIMEOUT, "deadline expired before live sync stream", {
+        indexName,
+        partitionId,
+        target
+      })
+    };
+  }
+  try {
+    const streamWork = deps.transport.stream(target, request, (chunk) => {
+      handleLiveSyncFrame(frameState, chunk);
+    });
+    await withDeadline(streamWork, remainingMs, indexName, "live-sync");
+  } catch (err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      error: new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TRANSPORT_FAILED, `live sync transport failed: ${cause}`, {
+        indexName,
+        partitionId,
+        target,
+        cause
+      })
+    };
+  }
+  if (frameState.error !== null) {
+    return { ok: false, error: frameState.error };
+  }
+  if (abortCheck()) {
+    return {
+      ok: false,
+      error: new NarsilError(ErrorCodes.SNAPSHOT_SYNC_ABORTED, "bootstrap sync aborted after live stream", {
+        indexName,
+        partitionId,
+        target
+      })
+    };
+  }
+  if (frameState.sawSnapshotFrame) {
+    return applyLiveSnapshotSync(
+      state,
+      entry,
+      indexName,
+      partitionId,
+      target,
+      frameState,
+      coordinatorSchema,
+      partitionCount,
+      deadline,
+      deps
+    );
   }
-  return { created: true };
-}
-function validateLocalSchema(engine, indexName, primaryNodeId, coordinatorSchema) {
-  const schemaError = validateRestoredSchema(engine, indexName, primaryNodeId, coordinatorSchema);
-  if (schemaError !== null) {
-    return schemaError;
+  if (frameState.syncEntries.length > 0) {
+    return applyLiveIncrementalSync(
+      indexName,
+      partitionId,
+      target,
+      frameState.syncEntries,
+      logState.lastSeqNo + 1,
+      logState.lastPrimaryTerm,
+      coordinatorSchema,
+      partitionCount,
+      deps
+    );
   }
-  return { created: false };
+  return {
+    ok: false,
+    error: new NarsilError(ErrorCodes.SNAPSHOT_SYNC_CHUNK_MISSING, "live sync stream ended without sync frames", {
+      indexName,
+      partitionId,
+      target
+    })
+  };
 }
-function validateLocalPartitionCount(engine, indexName, primaryNodeId, partitionCount) {
-  let localPartitionCount;
+
+// src/distribution/cluster-node/bootstrap-sync/live.ts
+async function resolveLivePartitionCount(coordinator, indexName, partitionId, primaryNodeId, abortPromise) {
   try {
-    localPartitionCount = engine.getStats(indexName).partitionCount;
+    const winner = await Promise.race([coordinator.getAllocation(indexName), abortPromise]);
+    if (winner === ABORT_SENTINEL) {
+      return "aborted";
+    }
+    const allocation = winner;
+    if (allocation === null) {
+      return {
+        error: new NarsilError(
+          ErrorCodes.SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE,
+          `coordinator has no allocation for index '${indexName}'`,
+          { indexName, primaryNodeId }
+        )
+      };
+    }
+    const assignment = allocation.assignments.get(partitionId);
+    if (assignment === void 0) {
+      return {
+        error: new NarsilError(
+          ErrorCodes.SNAPSHOT_SYNC_NOT_ASSIGNED,
+          `No assignment exists for partition ${partitionId} of index '${indexName}'`,
+          { indexName, partitionId, primaryNodeId }
+        )
+      };
+    }
+    if (assignment.primary !== primaryNodeId) {
+      return {
+        error: new NarsilError(
+          ErrorCodes.SNAPSHOT_SYNC_NOT_ASSIGNED,
+          `Partition ${partitionId} of index '${indexName}' is no longer primary on '${primaryNodeId}'`,
+          { indexName, partitionId, primaryNodeId, currentPrimary: assignment.primary }
+        )
+      };
+    }
+    return { partitionCount: allocation.assignments.size };
   } catch (err) {
     const cause = err instanceof Error ? err.message : String(err);
-    return new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED,
-      `failed to read local partition count for '${indexName}': ${cause}`,
-      { indexName, primaryNodeId, cause }
-    );
-  }
-  if (localPartitionCount !== partitionCount) {
-    return new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED,
-      `local partition count ${localPartitionCount} disagrees with coordinator partition count ${partitionCount}`,
-      { indexName, primaryNodeId, localPartitionCount, partitionCount }
-    );
+    return {
+      error: new NarsilError(
+        ErrorCodes.SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE,
+        `coordinator.getAllocation failed: ${cause}`,
+        {
+          indexName,
+          partitionId,
+          primaryNodeId,
+          cause
+        }
+      )
+    };
   }
-  return { created: false };
 }
-async function applySyncEntries(indexName, partitionId, entriesPayloads, expectedFirstSeqNo, localPrimaryTerm, deps) {
-  const terminalError = validateSyncEntryBatchTermination(entriesPayloads);
-  if (terminalError !== null) {
-    return { ok: false, error: terminalError };
+async function executeLiveBootstrapSync(state, entry, indexName, partitionId, primaryNodeId, deps, deadlineMs, deadline, abortCheck) {
+  const schemaResult = await loadCoordinatorSchema(deps.coordinator, indexName, primaryNodeId, entry.abortPromise);
+  if (schemaResult === "aborted") {
+    surfaceAborted(deps, indexName, primaryNodeId);
+    return false;
   }
-  const log = deps.getReplicationLog(indexName, partitionId);
-  let expectedSeqNo = expectedFirstSeqNo;
-  let entriesApplied = 0;
-  for (const payload of entriesPayloads) {
-    for (const entry of payload.entries) {
-      const entryError = validateSyncEntryForApply(entry, indexName, partitionId, expectedSeqNo, localPrimaryTerm, log);
-      if (entryError !== null) {
-        return { ok: false, error: entryError };
-      }
-      try {
-        await deps.applyReplicationEntry(entry);
-        log.appendCommitted(entry);
-      } catch (err) {
-        const cause = err instanceof Error ? err.message : String(err);
-        return {
-          ok: false,
-          error: new NarsilError(ErrorCodes.REPLICATION_ENTRY_INVALID, `failed to apply sync entry: ${cause}`, {
-            indexName,
-            partitionId,
-            seqNo: entry.seqNo,
-            cause
-          })
-        };
-      }
-      expectedSeqNo = entry.seqNo + 1;
-      entriesApplied += 1;
-    }
+  if ("error" in schemaResult) {
+    surfaceError(deps, indexName, primaryNodeId, schemaResult.error);
+    return false;
   }
-  return {
-    ok: true,
-    entriesApplied,
-    newSeqNo: expectedSeqNo - 1
-  };
-}
-function validateSyncEntryBatchTermination(entriesPayloads) {
-  if (entriesPayloads.length === 0) {
-    return null;
+  if (abortCheck()) {
+    surfaceAborted(deps, indexName, primaryNodeId);
+    return false;
   }
-  for (let i = 0; i < entriesPayloads.length - 1; i += 1) {
-    if (entriesPayloads[i].isLast) {
-      return new NarsilError(ErrorCodes.SNAPSHOT_SYNC_FRAME_INVALID, "sync_entries marked isLast before final batch");
-    }
+  const allocationResult = await resolveLivePartitionCount(
+    deps.coordinator,
+    indexName,
+    partitionId,
+    primaryNodeId,
+    entry.abortPromise
+  );
+  if (allocationResult === "aborted") {
+    surfaceAborted(deps, indexName, primaryNodeId);
+    return false;
   }
-  if (!entriesPayloads[entriesPayloads.length - 1].isLast) {
-    return new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_FRAME_INVALID,
-      "live sync stream ended before final sync_entries batch"
-    );
+  if ("error" in allocationResult) {
+    surfaceError(deps, indexName, primaryNodeId, allocationResult.error);
+    return false;
   }
-  return null;
-}
-function validateSyncEntryForApply(entry, indexName, partitionId, expectedSeqNo, localPrimaryTerm, log) {
-  if (entry.indexName !== indexName || entry.partitionId !== partitionId) {
-    return new NarsilError(
-      ErrorCodes.REPLICATION_ENTRY_INVALID,
-      "replication entry scope does not match bootstrap target",
-      {
-        expectedIndexName: indexName,
-        expectedPartitionId: partitionId,
-        entryIndexName: entry.indexName,
-        entryPartitionId: entry.partitionId
-      }
+  if (Date.now() >= deadline) {
+    surfaceError(
+      deps,
+      indexName,
+      primaryNodeId,
+      new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TIMEOUT, "bootstrap sync exceeded deadline before starting live sync", {
+        indexName,
+        deadlineMs
+      })
     );
+    return false;
   }
-  if (entry.seqNo !== expectedSeqNo) {
-    return new NarsilError(
-      ErrorCodes.REPLICATION_ENTRY_INVALID,
-      `Out-of-order sync entry ${entry.seqNo}; expected ${expectedSeqNo}`,
-      { indexName, partitionId, seqNo: entry.seqNo, expectedSeqNo }
-    );
+  const targetsResult = await resolveTransportTargets(indexName, primaryNodeId, deps.resolveNodeTargets);
+  if (targetsResult instanceof NarsilError) {
+    surfaceError(deps, indexName, primaryNodeId, targetsResult);
+    return false;
   }
-  const validation = validateReplicationEntry(entry, localPrimaryTerm, log);
-  if (!validation.valid) {
-    return new NarsilError(
-      ErrorCodes.REPLICATION_ENTRY_INVALID,
-      `Invalid sync entry ${entry.seqNo}: ${validation.error ?? "unknown validation error"}`,
-      { indexName, partitionId, seqNo: entry.seqNo }
-    );
+  const syncResult = await syncFromAnyTarget(
+    state,
+    entry,
+    indexName,
+    partitionId,
+    primaryNodeId,
+    targetsResult,
+    schemaResult.schema,
+    allocationResult.partitionCount,
+    deadline,
+    deps,
+    abortCheck
+  );
+  if (!syncResult.ok) {
+    if (syncResult.error.code === ErrorCodes.SNAPSHOT_SYNC_ABORTED) {
+      surfaceAborted(deps, indexName, primaryNodeId);
+      return false;
+    }
+    if (syncResult.error.details.alreadySurfaced !== true) {
+      surfaceError(deps, indexName, primaryNodeId, syncResult.error);
+    }
+    return false;
   }
-  return null;
-}
-function streamFailureToError(failure) {
-  return new NarsilError(failure.code, failure.message, failure.details);
-}
-function anotherBootstrapOwnsKey(state, key, self) {
-  const current = state.inFlight.get(key);
-  if (current === void 0) {
+  if (abortCheck()) {
+    surfaceAborted(deps, indexName, primaryNodeId);
     return false;
   }
-  return current !== self;
+  if (syncResult.snapshotHeader !== null) {
+    deps.onSnapshotApplied?.(indexName, partitionId, syncResult.snapshotHeader);
+  }
+  state.completed.add(entryKey(indexName, partitionId));
+  return true;
 }
+
+// src/distribution/cluster-node/bootstrap-sync/snapshot-restore.ts
 async function fetchSchemaAndPrepare(entry, indexName, primaryNodeId, deps) {
   const dropError = await dropExistingIndex(deps.engine, indexName, primaryNodeId);
   if (dropError !== null) {
@@ -5028,6 +4712,150 @@ async function applyRestore(state, entry, indexName, primaryNodeId, bytes, coord
   return true;
 }
 
+// src/distribution/cluster-node/bootstrap-sync/index.ts
+async function runBootstrapSync(state, indexName, partitionId, primaryNodeId, deps) {
+  const validationError = validateArguments(indexName, partitionId, primaryNodeId);
+  if (validationError !== null) {
+    surfaceError(deps, indexName, primaryNodeId, validationError);
+    return false;
+  }
+  const key = entryKey(indexName, partitionId);
+  if (state.completed.has(key)) {
+    return true;
+  }
+  const existing = state.inFlight.get(key);
+  if (existing !== void 0) {
+    const result = await Promise.race([existing.promise, existing.abortPromise]);
+    if (result === ABORT_SENTINEL) {
+      return false;
+    }
+    return result;
+  }
+  const entry = createEntry(state, indexName, partitionId, key);
+  entry.promise = executeBootstrapSync(state, entry, indexName, partitionId, primaryNodeId, deps).finally(() => {
+    const current = state.inFlight.get(key);
+    if (current === entry) {
+      state.inFlight.delete(key);
+    }
+    if (!state.completed.has(key) && !state.inFlight.has(key)) {
+      const currentGen = state.generations.get(key);
+      if (currentGen !== void 0 && currentGen !== entry.generation) {
+        state.generations.delete(key);
+      }
+    }
+  });
+  state.inFlight.set(key, entry);
+  return entry.promise;
+}
+async function executeBootstrapSync(state, entry, indexName, partitionId, primaryNodeId, deps) {
+  const deadlineMs = deps.deadlineMs ?? DEFAULT_BOOTSTRAP_SYNC_DEADLINE_MS;
+  const deadline = Date.now() + deadlineMs;
+  const key = entryKey(indexName, partitionId);
+  const abortCheck = () => {
+    const currentGeneration = state.generations.get(key) ?? 0;
+    if (currentGeneration !== entry.generation) {
+      entry.aborted = true;
+    }
+    return entry.aborted;
+  };
+  if (hasLiveBootstrapSyncDeps(deps)) {
+    return executeLiveBootstrapSync(
+      state,
+      entry,
+      indexName,
+      partitionId,
+      primaryNodeId,
+      deps,
+      deadlineMs,
+      deadline,
+      abortCheck
+    );
+  }
+  const schemaResult = await fetchSchemaAndPrepare(entry, indexName, primaryNodeId, deps);
+  if (schemaResult === "aborted") {
+    surfaceAborted(deps, indexName, primaryNodeId);
+    return false;
+  }
+  if (schemaResult === null) {
+    return false;
+  }
+  if (abortCheck()) {
+    surfaceAborted(deps, indexName, primaryNodeId);
+    return false;
+  }
+  if (Date.now() >= deadline) {
+    surfaceError(
+      deps,
+      indexName,
+      primaryNodeId,
+      new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TIMEOUT, "bootstrap sync exceeded deadline before fetching snapshot", {
+        indexName,
+        deadlineMs
+      })
+    );
+    return false;
+  }
+  const targetsResult = await resolveTransportTargets(indexName, primaryNodeId, deps.resolveNodeTargets);
+  if (targetsResult instanceof NarsilError) {
+    surfaceError(deps, indexName, primaryNodeId, targetsResult);
+    return false;
+  }
+  const fetchDeps = { transport: deps.transport, sourceNodeId: deps.sourceNodeId };
+  const fetchResult = await fetchSnapshotFromAnyTarget(
+    indexName,
+    primaryNodeId,
+    targetsResult,
+    deadline,
+    fetchDeps,
+    abortCheck,
+    partitionId
+  );
+  if (!fetchResult.ok) {
+    if (fetchResult.code === ErrorCodes.SNAPSHOT_SYNC_ABORTED) {
+      surfaceAborted(deps, indexName, primaryNodeId);
+      return false;
+    }
+    surfaceError(
+      deps,
+      indexName,
+      primaryNodeId,
+      new NarsilError(fetchResult.code, fetchResult.message, {
+        indexName,
+        primaryNodeId,
+        ...fetchResult.details
+      })
+    );
+    return false;
+  }
+  if (abortCheck()) {
+    surfaceAborted(deps, indexName, primaryNodeId);
+    return false;
+  }
+  const restoreSucceeded = await applyRestore(
+    state,
+    entry,
+    indexName,
+    primaryNodeId,
+    fetchResult.bytes,
+    schemaResult,
+    deadline,
+    deps
+  );
+  if (!restoreSucceeded) {
+    return false;
+  }
+  if (abortCheck()) {
+    if (!anotherBootstrapOwnsKey(state, key, entry)) {
+      await dropRestoredIndexQuietly(deps.engine, indexName, deps);
+    }
+    surfaceAborted(deps, indexName, primaryNodeId);
+    return false;
+  }
+  deps.onSnapshotApplied?.(indexName, partitionId, fetchResult.header);
+  state.completed.add(key);
+  return true;
+}
+
 // src/distribution/cluster-node/local-engine.ts
 async function createClusterLocalEngine(config) {
   const core = createEngineCore(config);
@@ -5257,38 +5085,6 @@ async function applyReplicationEntry(core, entry) {
     requestId: `replicate-entry-remove-${entry.indexName}-${entry.partitionId}-${entry.seqNo}`
   });
 }
-function decideSyncTier(log, replicaLastSeqNo) {
-  const oldest = log.oldestSeqNo;
-  if (oldest === void 0) {
-    if (log.committedSeqNo === 0) {
-      return replicaLastSeqNo === 0 ? "incremental" : "snapshot";
-    }
-    return replicaLastSeqNo >= log.committedSeqNo ? "incremental" : "snapshot";
-  }
-  if (oldest <= replicaLastSeqNo + 1) {
-    return "incremental";
-  }
-  return "snapshot";
-}
-function validateSyncRequest(decoded) {
-  if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) {
-    throw new Error("Invalid SyncRequestPayload: expected an object");
-  }
-  const record = decoded;
-  if (typeof record.indexName !== "string") {
-    throw new Error('Invalid SyncRequestPayload: "indexName" must be a string');
-  }
-  if (typeof record.partitionId !== "number" || !Number.isInteger(record.partitionId) || record.partitionId < 0) {
-    throw new Error('Invalid SyncRequestPayload: "partitionId" must be a non-negative integer');
-  }
-  if (typeof record.lastSeqNo !== "number" || !Number.isInteger(record.lastSeqNo) || record.lastSeqNo < 0) {
-    throw new Error('Invalid SyncRequestPayload: "lastSeqNo" must be a non-negative integer');
-  }
-  if (typeof record.lastPrimaryTerm !== "number" || !Number.isInteger(record.lastPrimaryTerm) || record.lastPrimaryTerm < 0) {
-    throw new Error('Invalid SyncRequestPayload: "lastPrimaryTerm" must be a non-negative integer');
-  }
-  return record;
-}
 
 // src/distribution/cluster-node/snapshot-auth.ts
 var BOOTSTRAPPABLE_STATES = /* @__PURE__ */ new Set(["ACTIVE", "INITIALISING", "MIGRATING"]);
@@ -5319,133 +5115,35 @@ async function authorizeSnapshotRequest(coordinator, indexName, sourceId) {
       continue;
     }
     sawAssignment = true;
-    if (!BOOTSTRAPPABLE_STATES.has(assignment.state)) {
-      continue;
-    }
-    if (isPrimary) {
-      return { outcome: "authorized" };
-    }
-    if (!assignmentAllowsReplicaBootstrap(assignment, sourceId)) {
-      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}'`
-  };
-}
-function assignmentAllowsReplicaBootstrap(assignment, sourceId) {
-  if (assignment.state === "INITIALISING" || assignment.state === "MIGRATING") {
-    return true;
-  }
-  return assignment.inSyncSet.includes(sourceId);
-}
-var SNAPSHOT_SYNC_ERROR_TYPE = `${ReplicationMessageTypes.SNAPSHOT_SYNC_REQUEST}.error`;
-var CHUNK_YIELD_INTERVAL_MS = 8;
-function createSingleResponseSink(respond) {
-  const sink = ((response) => {
-    if (sink.closed) {
-      return;
-    }
-    respond(response);
-  });
-  sink.closed = false;
-  return sink;
-}
-async function streamSnapshotToReplica(sink, nodeId, requestId, indexName, build, metadata, options = {}) {
-  const snapshotBytes = build.bytes;
-  const totalBytes = snapshotBytes.byteLength;
-  const checksum = build.checksum;
-  const header = {
-    lastSeqNo: metadata.lastSeqNo,
-    primaryTerm: metadata.primaryTerm,
-    partitionId: metadata.partitionId,
-    indexName,
-    checksum
-  };
-  const startPayload = { header, totalBytes };
-  const startBytes = encode(startPayload);
-  assertMessageWithinLimit(startBytes, "SNAPSHOT_START");
-  respondMessage(sink, ReplicationMessageTypes.SNAPSHOT_START, nodeId, requestId, startBytes);
-  await yieldToEventLoop();
-  let offset = 0;
-  let lastYieldAt = now();
-  while (offset < totalBytes) {
-    const end = Math.min(offset + SNAPSHOT_CHUNK_SIZE, totalBytes);
-    const chunk = snapshotBytes.subarray(offset, end);
-    const chunkPayload = {
-      partitionId: metadata.partitionId,
-      indexName,
-      offset,
-      data: chunk
-    };
-    const chunkBytes = encode(chunkPayload);
-    assertMessageWithinLimit(chunkBytes, "SNAPSHOT_CHUNK");
-    respondMessage(sink, ReplicationMessageTypes.SNAPSHOT_CHUNK, nodeId, requestId, chunkBytes);
-    offset = end;
-    if (offset < totalBytes && now() - lastYieldAt >= CHUNK_YIELD_INTERVAL_MS) {
-      await yieldToEventLoop();
-      lastYieldAt = now();
+    if (!BOOTSTRAPPABLE_STATES.has(assignment.state)) {
+      continue;
     }
+    if (isPrimary) {
+      return { outcome: "authorized" };
+    }
+    if (!assignmentAllowsReplicaBootstrap(assignment, sourceId)) {
+      continue;
+    }
+    return { outcome: "authorized" };
   }
-  await yieldToEventLoop();
-  const endPayload = {
-    partitionId: metadata.partitionId,
-    indexName,
-    totalBytes,
-    checksum
-  };
-  const endBytes = encode(endPayload);
-  assertMessageWithinLimit(endBytes, "SNAPSHOT_END");
-  respondMessage(sink, ReplicationMessageTypes.SNAPSHOT_END, nodeId, requestId, endBytes);
-  if (options.closeOnEnd !== false) {
-    sink.closed = true;
-  }
-}
-function now() {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return performance.now();
+  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 Date.now();
-}
-function yieldToEventLoop() {
-  return new Promise((resolve) => {
-    if (typeof setImmediate === "function") {
-      setImmediate(resolve);
-      return;
-    }
-    setTimeout(resolve, 0);
-  });
-}
-function respondMessage(sink, type, sourceId, requestId, payload) {
-  sink({ type, sourceId, requestId, payload });
+  return {
+    outcome: "denied",
+    code: ErrorCodes.SNAPSHOT_SYNC_UNAUTHORIZED,
+    reason: `node '${sourceId}' is not an assigned replica for index '${indexName}'`
+  };
 }
-function assertMessageWithinLimit(bytes, label) {
-  if (bytes.byteLength > MAX_MESSAGE_SIZE_BYTES) {
-    throw new NarsilError(
-      ErrorCodes.CONFIG_INVALID,
-      `${label} payload (${bytes.byteLength} bytes) exceeds transport message limit (${MAX_MESSAGE_SIZE_BYTES})`
-    );
+function assignmentAllowsReplicaBootstrap(assignment, sourceId) {
+  if (assignment.state === "INITIALISING" || assignment.state === "MIGRATING") {
+    return true;
   }
-}
-function respondError(sink, sourceId, requestId, code, message) {
-  const response = {
-    type: SNAPSHOT_SYNC_ERROR_TYPE,
-    sourceId,
-    requestId,
-    payload: encode({ error: true, code, message })
-  };
-  sink(response);
-  sink.closed = true;
+  return assignment.inSyncSet.includes(sourceId);
 }
 
 // src/distribution/cluster-node/snapshot-cache.ts
@@ -5576,37 +5274,106 @@ async function acquireSnapshotBuild(state, indexName, builder) {
   state.cache.set(indexName, entry);
   return entry.promise;
 }
-
-// src/distribution/cluster-node/snapshot-sync-handler.ts
-var INDEX_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-var MAX_SOURCE_ID_LENGTH = 256;
-function containsControlCharacter(value) {
-  for (let i = 0; i < value.length; i++) {
-    const code = value.charCodeAt(i);
-    if (code < 32) {
-      return true;
+var SNAPSHOT_SYNC_ERROR_TYPE = `${ReplicationMessageTypes.SNAPSHOT_SYNC_REQUEST}.error`;
+var CHUNK_YIELD_INTERVAL_MS = 8;
+function createSingleResponseSink(respond) {
+  const sink = ((response) => {
+    if (sink.closed) {
+      return;
     }
-    if (code >= 127 && code <= 159) {
-      return true;
+    respond(response);
+  });
+  sink.closed = false;
+  return sink;
+}
+async function streamSnapshotToReplica(sink, nodeId, requestId, indexName, build, metadata, options = {}) {
+  const snapshotBytes = build.bytes;
+  const totalBytes = snapshotBytes.byteLength;
+  const checksum = build.checksum;
+  const header = {
+    lastSeqNo: metadata.lastSeqNo,
+    primaryTerm: metadata.primaryTerm,
+    partitionId: metadata.partitionId,
+    indexName,
+    checksum
+  };
+  const startPayload = { header, totalBytes };
+  const startBytes = encode(startPayload);
+  assertMessageWithinLimit(startBytes, "SNAPSHOT_START");
+  respondMessage(sink, ReplicationMessageTypes.SNAPSHOT_START, nodeId, requestId, startBytes);
+  await yieldToEventLoop();
+  let offset = 0;
+  let lastYieldAt = now();
+  while (offset < totalBytes) {
+    const end = Math.min(offset + SNAPSHOT_CHUNK_SIZE, totalBytes);
+    const chunk = snapshotBytes.subarray(offset, end);
+    const chunkPayload = {
+      partitionId: metadata.partitionId,
+      indexName,
+      offset,
+      data: chunk
+    };
+    const chunkBytes = encode(chunkPayload);
+    assertMessageWithinLimit(chunkBytes, "SNAPSHOT_CHUNK");
+    respondMessage(sink, ReplicationMessageTypes.SNAPSHOT_CHUNK, nodeId, requestId, chunkBytes);
+    offset = end;
+    if (offset < totalBytes && now() - lastYieldAt >= CHUNK_YIELD_INTERVAL_MS) {
+      await yieldToEventLoop();
+      lastYieldAt = now();
     }
-    if (code === 8232 || code === 8233 || code === 65279) {
-      return true;
+  }
+  await yieldToEventLoop();
+  const endPayload = {
+    partitionId: metadata.partitionId,
+    indexName,
+    totalBytes,
+    checksum
+  };
+  const endBytes = encode(endPayload);
+  assertMessageWithinLimit(endBytes, "SNAPSHOT_END");
+  respondMessage(sink, ReplicationMessageTypes.SNAPSHOT_END, nodeId, requestId, endBytes);
+  if (options.closeOnEnd !== false) {
+    sink.closed = true;
+  }
+}
+function now() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function yieldToEventLoop() {
+  return new Promise((resolve) => {
+    if (typeof setImmediate === "function") {
+      setImmediate(resolve);
+      return;
     }
+    setTimeout(resolve, 0);
+  });
+}
+function respondMessage(sink, type, sourceId, requestId, payload) {
+  sink({ type, sourceId, requestId, payload });
+}
+function assertMessageWithinLimit(bytes, label) {
+  if (bytes.byteLength > MAX_MESSAGE_SIZE_BYTES) {
+    throw new NarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      `${label} payload (${bytes.byteLength} bytes) exceeds transport message limit (${MAX_MESSAGE_SIZE_BYTES})`
+    );
   }
-  return false;
 }
-var MAX_SNAPSHOT_SYNC_REQUEST_BYTES = 4096;
-var REQUEST_DECODE_OPTIONS = {
-  maxMapLength: 16,
-  maxArrayLength: 16,
-  maxStrLength: MAX_INDEX_NAME_LENGTH,
-  maxBinLength: 0,
-  maxExtLength: 0,
-  keyDecoder: null
-};
-function createSnapshotSyncHandlerState(maxConcurrent = DEFAULT_MAX_CONCURRENT_SNAPSHOTS, maxPerSource = DEFAULT_MAX_PER_SOURCE_SNAPSHOTS, maxStreamsPerIndex = DEFAULT_MAX_STREAMS_PER_INDEX) {
-  return createSnapshotCacheState(maxConcurrent, maxPerSource, maxStreamsPerIndex);
+function respondError(sink, sourceId, requestId, code, message) {
+  const response = {
+    type: SNAPSHOT_SYNC_ERROR_TYPE,
+    sourceId,
+    requestId,
+    payload: encode({ error: true, code, message })
+  };
+  sink(response);
+  sink.closed = true;
 }
+
+// src/distribution/cluster-node/snapshot-sync-handler/metadata.ts
 async function defaultSnapshotHeaderMetadataProvider(coordinator, indexName) {
   try {
     const allocation = await coordinator.getAllocation(indexName);
@@ -5628,81 +5395,24 @@ async function defaultSnapshotHeaderMetadataProvider(coordinator, indexName) {
     primaryTerm: 0,
     lastSeqNo: SNAPSHOT_HEADER_SENTINEL_SEQNO
   };
-}
-async function handleSnapshotSyncRequest(message, respond, deps) {
-  const sink = createSingleResponseSink(respond);
-  try {
-    if (message.payload.byteLength > MAX_SNAPSHOT_SYNC_REQUEST_BYTES) {
-      respondError(
-        sink,
-        deps.nodeId,
-        message.requestId,
-        ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
-        `SNAPSHOT_SYNC_REQUEST payload (${message.payload.byteLength} bytes) exceeds the ${MAX_SNAPSHOT_SYNC_REQUEST_BYTES} byte limit`
-      );
-      return;
-    }
-    await runSnapshotSyncRequest(message, sink, deps);
-  } catch (err) {
-    const code = err instanceof NarsilError ? err.code : ErrorCodes.SNAPSHOT_SYNC_SNAPSHOT_FAILED;
-    const errMessage = err instanceof Error ? err.message : String(err);
-    respondError(sink, deps.nodeId, message.requestId, code, errMessage);
-  }
-}
-async function runSnapshotSyncRequest(message, sink, deps) {
-  const request = decodeRequest(message, sink, deps);
-  if (request === null) {
-    return;
-  }
-  await streamValidatedSnapshotRequest(message, sink, request, deps);
-}
-async function streamValidatedSnapshotRequest(message, sink, request, deps, options = {}) {
-  const sourceIdError = validateSourceId(message.sourceId);
-  if (sourceIdError !== null) {
-    respondError(sink, deps.nodeId, message.requestId, ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID, sourceIdError);
-    return;
-  }
-  const authResult = await authorizeSnapshotRequest(deps.coordinator, request.indexName, message.sourceId);
-  if (authResult.outcome === "denied") {
-    respondError(sink, deps.nodeId, message.requestId, authResult.code, authResult.reason);
-    return;
-  }
-  const existingIndex = deps.engine.listIndexes().find((idx) => idx.name === request.indexName);
-  if (existingIndex === void 0) {
-    respondError(
-      sink,
-      deps.nodeId,
-      message.requestId,
-      ErrorCodes.SNAPSHOT_SYNC_INDEX_NOT_FOUND,
-      `Index '${request.indexName}' is not hosted on this node`
-    );
-    return;
-  }
-  await acquireAndStream(message, sink, request, deps, options);
-}
-function decodeRequest(message, sink, deps) {
-  try {
-    const decoded = decode(message.payload, REQUEST_DECODE_OPTIONS);
-    return validateSnapshotSyncRequestPayload(decoded);
-  } catch (err) {
-    const code = err instanceof NarsilError ? err.code : ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID;
-    const errMessage = err instanceof Error ? err.message : String(err);
-    respondError(sink, deps.nodeId, message.requestId, code, errMessage);
-    return null;
-  }
-}
-function validateSourceId(sourceId) {
-  if (typeof sourceId !== "string" || sourceId.length === 0) {
-    return "request sourceId is missing";
-  }
-  if (sourceId.length > MAX_SOURCE_ID_LENGTH) {
-    return `request sourceId exceeds ${MAX_SOURCE_ID_LENGTH} characters`;
+}
+async function resolveHeaderMetadata(deps, indexName, partitionId) {
+  const provider = deps.resolveHeaderMetadata;
+  if (provider === void 0) {
+    return defaultSnapshotHeaderMetadataProvider(deps.coordinator, indexName);
   }
-  if (containsControlCharacter(sourceId)) {
-    return "request sourceId contains control characters";
+  try {
+    return await provider(indexName, partitionId);
+  } catch (_) {
+    return {
+      partitionId: SNAPSHOT_HEADER_SENTINEL_PARTITION_ID,
+      primaryTerm: 0,
+      lastSeqNo: SNAPSHOT_HEADER_SENTINEL_SEQNO
+    };
   }
-  return null;
 }
+
+// src/distribution/cluster-node/snapshot-sync-handler/stream.ts
 async function acquireAndStream(message, sink, request, deps, options) {
   const { indexName } = request;
   let sourceHandle;
@@ -5783,241 +5493,411 @@ function buildSnapshotForRequest(deps, indexName, options) {
   }
   return buildSnapshot(deps, indexName);
 }
-async function resolveHeaderMetadata(deps, indexName, partitionId) {
-  const provider = deps.resolveHeaderMetadata;
-  if (provider === void 0) {
-    return defaultSnapshotHeaderMetadataProvider(deps.coordinator, indexName);
+var INDEX_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var MAX_SOURCE_ID_LENGTH = 256;
+function containsControlCharacter(value) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 32) {
+      return true;
+    }
+    if (code >= 127 && code <= 159) {
+      return true;
+    }
+    if (code === 8232 || code === 8233 || code === 65279) {
+      return true;
+    }
   }
+  return false;
+}
+var MAX_SNAPSHOT_SYNC_REQUEST_BYTES = 4096;
+var REQUEST_DECODE_OPTIONS = {
+  maxMapLength: 16,
+  maxArrayLength: 16,
+  maxStrLength: MAX_INDEX_NAME_LENGTH,
+  maxBinLength: 0,
+  maxExtLength: 0,
+  keyDecoder: null
+};
+function decodeRequest(message, sink, deps) {
   try {
-    return await provider(indexName, partitionId);
-  } catch (_) {
-    return {
-      partitionId: SNAPSHOT_HEADER_SENTINEL_PARTITION_ID,
-      primaryTerm: 0,
-      lastSeqNo: SNAPSHOT_HEADER_SENTINEL_SEQNO
-    };
+    const decoded = decode(message.payload, REQUEST_DECODE_OPTIONS);
+    return validateSnapshotSyncRequestPayload(decoded);
+  } catch (err) {
+    const code = err instanceof NarsilError ? err.code : ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID;
+    const errMessage = err instanceof Error ? err.message : String(err);
+    respondError(sink, deps.nodeId, message.requestId, code, errMessage);
+    return null;
+  }
+}
+function validateSourceId(sourceId) {
+  if (typeof sourceId !== "string" || sourceId.length === 0) {
+    return "request sourceId is missing";
+  }
+  if (sourceId.length > MAX_SOURCE_ID_LENGTH) {
+    return `request sourceId exceeds ${MAX_SOURCE_ID_LENGTH} characters`;
+  }
+  if (containsControlCharacter(sourceId)) {
+    return "request sourceId contains control characters";
+  }
+  return null;
+}
+function validateSnapshotSyncRequestPayload(decoded) {
+  if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) {
+    throw new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
+      "Invalid SnapshotSyncRequestPayload: expected an object"
+    );
+  }
+  const record = decoded;
+  const indexName = record.indexName;
+  if (typeof indexName !== "string" || indexName.length === 0) {
+    throw new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
+      'Invalid SnapshotSyncRequestPayload: "indexName" must be a non-empty string'
+    );
+  }
+  if (indexName.length > MAX_INDEX_NAME_LENGTH) {
+    throw new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
+      `Invalid SnapshotSyncRequestPayload: "indexName" must be at most ${MAX_INDEX_NAME_LENGTH} characters`,
+      { length: indexName.length, limit: MAX_INDEX_NAME_LENGTH }
+    );
+  }
+  if (!INDEX_NAME_PATTERN.test(indexName) || indexName.includes("..")) {
+    throw new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
+      'Invalid SnapshotSyncRequestPayload: "indexName" contains invalid characters'
+    );
+  }
+  const partitionId = record.partitionId;
+  if (partitionId !== void 0 && partitionId !== null) {
+    if (typeof partitionId !== "number" || !Number.isInteger(partitionId) || partitionId < 0) {
+      throw new NarsilError(
+        ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
+        'Invalid SnapshotSyncRequestPayload: "partitionId" must be a non-negative integer when provided'
+      );
+    }
+    return { indexName, partitionId };
+  }
+  return { indexName, partitionId: null };
+}
+
+// src/distribution/cluster-node/snapshot-sync-handler/index.ts
+function createSnapshotSyncHandlerState(maxConcurrent = DEFAULT_MAX_CONCURRENT_SNAPSHOTS, maxPerSource = DEFAULT_MAX_PER_SOURCE_SNAPSHOTS, maxStreamsPerIndex = DEFAULT_MAX_STREAMS_PER_INDEX) {
+  return createSnapshotCacheState(maxConcurrent, maxPerSource, maxStreamsPerIndex);
+}
+async function handleSnapshotSyncRequest(message, respond, deps) {
+  const sink = createSingleResponseSink(respond);
+  try {
+    if (message.payload.byteLength > MAX_SNAPSHOT_SYNC_REQUEST_BYTES) {
+      respondError(
+        sink,
+        deps.nodeId,
+        message.requestId,
+        ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
+        `SNAPSHOT_SYNC_REQUEST payload (${message.payload.byteLength} bytes) exceeds the ${MAX_SNAPSHOT_SYNC_REQUEST_BYTES} byte limit`
+      );
+      return;
+    }
+    await runSnapshotSyncRequest(message, sink, deps);
+  } catch (err) {
+    const code = err instanceof NarsilError ? err.code : ErrorCodes.SNAPSHOT_SYNC_SNAPSHOT_FAILED;
+    const errMessage = err instanceof Error ? err.message : String(err);
+    respondError(sink, deps.nodeId, message.requestId, code, errMessage);
+  }
+}
+async function runSnapshotSyncRequest(message, sink, deps) {
+  const request = decodeRequest(message, sink, deps);
+  if (request === null) {
+    return;
+  }
+  await streamValidatedSnapshotRequest(message, sink, request, deps);
+}
+async function streamValidatedSnapshotRequest(message, sink, request, deps, options = {}) {
+  const sourceIdError = validateSourceId(message.sourceId);
+  if (sourceIdError !== null) {
+    respondError(sink, deps.nodeId, message.requestId, ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID, sourceIdError);
+    return;
+  }
+  const authResult = await authorizeSnapshotRequest(deps.coordinator, request.indexName, message.sourceId);
+  if (authResult.outcome === "denied") {
+    respondError(sink, deps.nodeId, message.requestId, authResult.code, authResult.reason);
+    return;
+  }
+  const existingIndex = deps.engine.listIndexes().find((idx) => idx.name === request.indexName);
+  if (existingIndex === void 0) {
+    respondError(
+      sink,
+      deps.nodeId,
+      message.requestId,
+      ErrorCodes.SNAPSHOT_SYNC_INDEX_NOT_FOUND,
+      `Index '${request.indexName}' is not hosted on this node`
+    );
+    return;
+  }
+  await acquireAndStream(message, sink, request, deps, options);
+}
+async function handleSearch(message, respond, deps) {
+  const decoded = decode(message.payload);
+  const payload = validateSearchPayload(decoded);
+  const queryParams = {
+    term: payload.params.term ?? void 0,
+    fields: payload.params.fields ?? void 0,
+    filters: payload.params.filters ?? void 0,
+    boost: payload.params.boost ?? void 0,
+    scoring: payload.params.scoring,
+    tolerance: payload.params.tolerance ?? void 0,
+    minScore: payload.params.threshold ?? void 0,
+    limit: payload.params.limit,
+    offset: payload.params.offset,
+    searchAfter: payload.params.searchAfter ?? void 0,
+    sort: convertWireSortToLocal(payload.params.sort),
+    group: payload.params.group !== null ? { fields: [payload.params.group.field], maxPerGroup: payload.params.group.maxPerGroup } : void 0,
+    facets: convertWireFacetsToLocal(payload.params.facets, payload.facetShardSize ?? payload.params.facetSize),
+    vector: payload.params.vector !== null ? {
+      field: payload.params.vector.field,
+      value: payload.params.vector.value ?? void 0,
+      text: payload.params.vector.text ?? void 0,
+      similarity: payload.params.vector.similarity ?? void 0
+    } : void 0,
+    hybrid: payload.params.hybrid !== null ? { strategy: payload.params.hybrid.strategy, k: payload.params.hybrid.k, alpha: payload.params.hybrid.alpha } : void 0
+  };
+  const queryResult = await deps.engine.query(payload.indexName, queryParams);
+  const scored = queryResult.hits.map((hit) => ({
+    docId: hit.id,
+    score: hit.score,
+    sortValues: null
+  }));
+  const results = payload.partitionIds.map((partitionId) => ({
+    partitionId,
+    scored: partitionId === payload.partitionIds[0] ? scored : [],
+    totalHits: partitionId === payload.partitionIds[0] ? queryResult.count : 0
+  }));
+  const resultPayload = { results, facets: convertLocalFacetsToWire(queryResult.facets) };
+  respond({
+    type: QueryMessageTypes.SEARCH_RESULT,
+    sourceId: deps.nodeId,
+    requestId: message.requestId,
+    payload: encode(resultPayload)
+  });
+}
+async function handleFetch(message, respond, deps) {
+  const decoded = decode(message.payload);
+  const payload = validateFetchPayload(decoded);
+  const documents = [];
+  for (const docRef of payload.documentIds) {
+    const doc = await deps.engine.get(payload.indexName, docRef.docId);
+    if (doc !== void 0) {
+      documents.push({
+        docId: docRef.docId,
+        document: doc,
+        highlights: null
+      });
+    }
+  }
+  const resultPayload = { documents };
+  respond({
+    type: QueryMessageTypes.FETCH_RESULT,
+    sourceId: deps.nodeId,
+    requestId: message.requestId,
+    payload: encode(resultPayload)
+  });
+}
+async function handleStats(message, respond, deps) {
+  const decoded = decode(message.payload);
+  const payload = validateStatsPayload(decoded);
+  const stats = deps.engine.getStats(payload.indexName);
+  const resultPayload = {
+    totalDocuments: stats.documentCount,
+    docFrequencies: {},
+    totalFieldLengths: {}
+  };
+  respond({
+    type: QueryMessageTypes.STATS_RESULT,
+    sourceId: deps.nodeId,
+    requestId: message.requestId,
+    payload: encode(resultPayload)
+  });
+}
+function convertWireSortToLocal(wireSort) {
+  if (wireSort === null || wireSort.length === 0) {
+    return void 0;
+  }
+  const result = {};
+  for (const entry of wireSort) {
+    result[entry.field] = entry.direction;
   }
+  return result;
 }
-function validateSnapshotSyncRequestPayload(decoded) {
-  if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
-      "Invalid SnapshotSyncRequestPayload: expected an object"
-    );
+function convertWireFacetsToLocal(facets, limit) {
+  if (facets === null || facets.length === 0) {
+    return void 0;
   }
-  const record = decoded;
-  const indexName = record.indexName;
-  if (typeof indexName !== "string" || indexName.length === 0) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
-      'Invalid SnapshotSyncRequestPayload: "indexName" must be a non-empty string'
-    );
+  const result = {};
+  for (const field of facets) {
+    result[field] = limit !== null ? { limit } : {};
   }
-  if (indexName.length > MAX_INDEX_NAME_LENGTH) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
-      `Invalid SnapshotSyncRequestPayload: "indexName" must be at most ${MAX_INDEX_NAME_LENGTH} characters`,
-      { length: indexName.length, limit: MAX_INDEX_NAME_LENGTH }
-    );
+  return result;
+}
+function convertLocalFacetsToWire(facets) {
+  if (facets === void 0) {
+    return null;
   }
-  if (!INDEX_NAME_PATTERN.test(indexName) || indexName.includes("..")) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
-      'Invalid SnapshotSyncRequestPayload: "indexName" contains invalid characters'
-    );
+  const result = {};
+  for (const [field, facet] of Object.entries(facets)) {
+    result[field] = Object.entries(facet.values).map(([value, count]) => ({ value, count }));
   }
-  const partitionId = record.partitionId;
-  if (partitionId !== void 0 && partitionId !== null) {
-    if (typeof partitionId !== "number" || !Number.isInteger(partitionId) || partitionId < 0) {
-      throw new NarsilError(
-        ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
-        'Invalid SnapshotSyncRequestPayload: "partitionId" must be a non-negative integer when provided'
-      );
+  return result;
+}
+function decideSyncTier(log, replicaLastSeqNo) {
+  const oldest = log.oldestSeqNo;
+  if (oldest === void 0) {
+    if (log.committedSeqNo === 0) {
+      return replicaLastSeqNo === 0 ? "incremental" : "snapshot";
     }
-    return { indexName, partitionId };
+    return replicaLastSeqNo >= log.committedSeqNo ? "incremental" : "snapshot";
   }
-  return { indexName, partitionId: null };
+  if (oldest <= replicaLastSeqNo + 1) {
+    return "incremental";
+  }
+  return "snapshot";
 }
-async function replicateToReplicas(entry, inSyncReplicas, transport, sourceNodeId, resolveNodeTargets2) {
-  const uniqueReplicas = [...new Set(inSyncReplicas)];
-  if (uniqueReplicas.length === 0) {
-    return { acknowledged: [], failed: [] };
+function validateSyncRequest(decoded) {
+  if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) {
+    throw new Error("Invalid SyncRequestPayload: expected an object");
   }
-  const message = createEntryMessage(entry, sourceNodeId);
-  const sendResults = await Promise.allSettled(
-    uniqueReplicas.map((replicaNodeId) => sendToReplica(transport, replicaNodeId, message, resolveNodeTargets2))
-  );
-  const acknowledged = [];
-  const failed = [];
-  for (let i = 0; i < sendResults.length; i++) {
-    const result = sendResults[i];
-    const replicaNodeId = uniqueReplicas[i];
-    if (result.status === "rejected") {
-      if (result.reason instanceof TransportError) {
-        failed.push(replicaNodeId);
-        continue;
-      }
-      throw result.reason;
-    }
-    const response = result.value;
-    if (isMatchingAck(response, entry)) {
-      acknowledged.push(replicaNodeId);
-    } else {
-      failed.push(replicaNodeId);
-    }
+  const record = decoded;
+  if (typeof record.indexName !== "string") {
+    throw new Error('Invalid SyncRequestPayload: "indexName" must be a string');
   }
-  return { acknowledged, failed };
-}
-async function sendToReplica(transport, replicaNodeId, message, resolveNodeTargets2) {
-  const targets = resolveNodeTargets2 === void 0 ? [replicaNodeId] : await resolveNodeTargets2(replicaNodeId);
-  const resolvedTargets = targets.length > 0 ? targets : [replicaNodeId];
-  let lastError;
-  for (const target of resolvedTargets) {
-    try {
-      return await transport.send(target, message);
-    } catch (error) {
-      lastError = error;
-    }
+  if (typeof record.partitionId !== "number" || !Number.isInteger(record.partitionId) || record.partitionId < 0) {
+    throw new Error('Invalid SyncRequestPayload: "partitionId" must be a non-negative integer');
   }
-  throw lastError instanceof Error ? lastError : new Error(String(lastError));
-}
-function isMatchingAck(response, entry) {
-  if (response.type !== ReplicationMessageTypes.ACK) {
-    return false;
+  if (typeof record.lastSeqNo !== "number" || !Number.isInteger(record.lastSeqNo) || record.lastSeqNo < 0) {
+    throw new Error('Invalid SyncRequestPayload: "lastSeqNo" must be a non-negative integer');
   }
-  try {
-    const payload = validateAckPayload(decode(response.payload));
-    return payload.seqNo === entry.seqNo && payload.partitionId === entry.partitionId && payload.indexName === entry.indexName;
-  } catch {
-    return false;
+  if (typeof record.lastPrimaryTerm !== "number" || !Number.isInteger(record.lastPrimaryTerm) || record.lastPrimaryTerm < 0) {
+    throw new Error('Invalid SyncRequestPayload: "lastPrimaryTerm" must be a non-negative integer');
   }
+  return record;
 }
 
-// src/distribution/cluster-node/types.ts
-var DEFAULT_PARTITION_COUNT = 5;
-var DEFAULT_REPLICATION_FACTOR = 1;
-var DEFAULT_CAPACITY = {
-  memoryBytes: 8e9,
-  cpuCores: 4,
-  diskBytes: null
-};
-
-// src/distribution/cluster-node/write-routing.ts
-var MAX_REPLICATION_FACTOR = 255;
-function validateCreateIndexOptions(partitionCount, replicationFactor) {
-  if (!Number.isInteger(partitionCount) || partitionCount < 1 || partitionCount > MAX_PARTITION_COUNT) {
+// src/distribution/cluster-node/message-handler/sync.ts
+async function handleSyncRequestMessage(message, respond, deps) {
+  const request = validateSyncRequest(decode(message.payload));
+  const authResult = await authorizeSnapshotRequest(deps.coordinator, request.indexName, message.sourceId);
+  if (authResult.outcome === "denied") {
+    throw new NarsilError(authResult.code, authResult.reason, {
+      indexName: request.indexName,
+      partitionId: request.partitionId,
+      sourceNodeId: message.sourceId
+    });
+  }
+  const table = await deps.coordinator.getAllocation(request.indexName);
+  const assignment = table?.assignments.get(request.partitionId);
+  if (assignment === void 0) {
     throw new NarsilError(
-      ErrorCodes.CONFIG_INVALID,
-      `partitionCount must be an integer between 1 and ${MAX_PARTITION_COUNT}, received ${partitionCount}`,
-      { partitionCount }
+      ErrorCodes.SNAPSHOT_SYNC_NOT_ASSIGNED,
+      `No assignment exists for sync request partition ${request.partitionId} of index '${request.indexName}'`,
+      { indexName: request.indexName, partitionId: request.partitionId }
     );
   }
-  if (!Number.isInteger(replicationFactor) || replicationFactor < 0 || replicationFactor > MAX_REPLICATION_FACTOR) {
+  if (assignment.primary !== deps.nodeId) {
     throw new NarsilError(
-      ErrorCodes.CONFIG_INVALID,
-      `replicationFactor must be an integer between 0 and ${MAX_REPLICATION_FACTOR}, received ${replicationFactor}`,
-      { replicationFactor }
+      ErrorCodes.SNAPSHOT_SYNC_UNAUTHORIZED,
+      `Node '${deps.nodeId}' is not primary for sync request partition ${request.partitionId} of index '${request.indexName}'`,
+      {
+        indexName: request.indexName,
+        partitionId: request.partitionId,
+        localNodeId: deps.nodeId,
+        primaryNodeId: assignment.primary
+      }
     );
   }
-}
-async function routeCreateIndex(name, config, options, coordinator, engine) {
-  validateIndexName(name);
-  const partitionCount = options?.partitionCount ?? DEFAULT_PARTITION_COUNT;
-  const replicationFactor = options?.replicationFactor ?? DEFAULT_REPLICATION_FACTOR;
-  validateCreateIndexOptions(partitionCount, replicationFactor);
-  const constraints = {
-    zoneAwareness: false,
-    zoneAttribute: "zone",
-    maxShardsPerNode: null
-  };
-  const metadata = {
-    indexName: name,
-    partitionCount,
-    replicationFactor,
-    constraints
-  };
-  const stored = await putIndexMetadata(coordinator, metadata);
-  if (!stored) {
+  const sourceAssigned = assignment.primary === message.sourceId || assignment.replicas.includes(message.sourceId);
+  if (!sourceAssigned) {
     throw new NarsilError(
-      ErrorCodes.INDEX_ALREADY_EXISTS,
-      `Index '${name}' already exists in the cluster or a partial creation is pending`,
-      { indexName: name }
+      ErrorCodes.SNAPSHOT_SYNC_UNAUTHORIZED,
+      `Node '${message.sourceId}' is not assigned to partition ${request.partitionId} of index '${request.indexName}'`,
+      { indexName: request.indexName, partitionId: request.partitionId, sourceNodeId: message.sourceId }
     );
   }
-  try {
-    await coordinator.putSchema(name, config.schema);
-    await engine.createIndex(name, config);
-  } catch (createErr) {
-    let cleanupFailed = false;
-    let cleanupError;
-    try {
-      const currentBytes = await coordinator.get(`_narsil/index/${name}/config`);
-      if (currentBytes !== null) {
-        await coordinator.compareAndSet(`_narsil/index/${name}/config`, currentBytes, new Uint8Array(0));
+  if (request.lastPrimaryTerm > assignment.primaryTerm) {
+    throw new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
+      `Replica term ${request.lastPrimaryTerm} is newer than primary term ${assignment.primaryTerm}`,
+      {
+        indexName: request.indexName,
+        partitionId: request.partitionId,
+        lastPrimaryTerm: request.lastPrimaryTerm,
+        primaryTerm: assignment.primaryTerm
+      }
+    );
+  }
+  const log = deps.writeDeps.getReplicationLog(request.indexName, request.partitionId);
+  const tier = decideSyncTier(log, request.lastSeqNo);
+  if (tier === "incremental") {
+    sendSyncEntriesResponse(message, respond, deps, log.getEntriesFrom(request.lastSeqNo + 1));
+    return;
+  }
+  const snapshotSeqNo = log.committedSeqNo;
+  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) };
+      },
+      afterSnapshot: (trailingSink) => {
+        const entries = log.getEntriesFrom(snapshotSeqNo + 1);
+        sendSyncEntriesResponse(message, trailingSink, deps, entries);
       }
-    } catch (cleanErr) {
-      cleanupFailed = true;
-      cleanupError = cleanErr;
-    }
-    if (cleanupFailed) {
-      throw new NarsilError(
-        ErrorCodes.CONFIG_INVALID,
-        `Index creation for '${name}' failed and metadata cleanup also failed. The index may be in a partial state and require manual intervention.`,
-        {
-          indexName: name,
-          createError: createErr instanceof Error ? createErr.message : String(createErr),
-          cleanupError: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
-        }
-      );
     }
-    throw createErr;
-  }
-}
-function resolvePartitionId(docId, partitionCount) {
-  return fnv1a(docId) % partitionCount;
-}
-async function forwardInsertToRemote(indexName, document, docId, primaryNodeId, deps) {
-  const payload = {
-    indexName,
-    documentId: docId,
-    operation: "insert",
-    document: encode(document),
-    updateFields: null
-  };
-  const message = createForwardMessage(payload, deps.nodeId);
-  const response = await sendToNode(primaryNodeId, message, deps);
-  const decoded = decode(response.payload);
-  if (typeof decoded.documentId !== "string") {
-    throw new NarsilError(
-      ErrorCodes.QUERY_ROUTING_FAILED,
-      `Remote primary returned invalid forward response for index '${indexName}'`,
-      { indexName, primaryNodeId }
-    );
-  }
-  return decoded.documentId;
+  );
 }
-async function forwardRemoveToRemote(indexName, docId, primaryNodeId, deps) {
+function sendSyncEntriesResponse(message, respond, deps, entries) {
   const payload = {
-    indexName,
-    documentId: docId,
-    operation: "remove",
-    document: null,
-    updateFields: null
+    entries,
+    isLast: true
   };
-  const message = createForwardMessage(payload, deps.nodeId);
-  await sendToNode(primaryNodeId, message, deps);
+  respond({
+    type: ReplicationMessageTypes.SYNC_ENTRIES,
+    sourceId: deps.nodeId,
+    requestId: message.requestId,
+    payload: encode(payload)
+  });
 }
-async function sendToNode(nodeId, message, deps) {
-  const targets = await resolveNodeTargets(nodeId, deps);
-  let lastError;
-  for (const target of targets) {
-    try {
-      return await deps.transport.send(target, message);
-    } catch (error) {
-      lastError = error;
-    }
-  }
-  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+
+// src/distribution/cluster-node/types.ts
+var DEFAULT_PARTITION_COUNT = 5;
+var DEFAULT_REPLICATION_FACTOR = 1;
+var DEFAULT_CAPACITY = {
+  memoryBytes: 8e9,
+  cpuCores: 4,
+  diskBytes: null
+};
+
+// src/distribution/cluster-node/write-routing/assignment.ts
+function resolvePartitionId(docId, partitionCount) {
+  return fnv1a(docId) % partitionCount;
 }
 async function resolveNodeTargets(nodeId, deps) {
   if (deps.resolveNodeTargets === void 0) {
@@ -6029,7 +5909,7 @@ async function resolveNodeTargets(nodeId, deps) {
 function requireAssignedPrimary(assignment, indexName, partitionId) {
   if (assignment === void 0 || assignment.primary === null) {
     throw new NarsilError(
-      ErrorCodes.QUERY_ROUTING_FAILED,
+      ErrorCodes.PARTITION_UNASSIGNED,
       `No primary assigned for partition ${partitionId} of index '${indexName}'`,
       { indexName, partitionId }
     );
@@ -6053,13 +5933,27 @@ async function resolvePrimaryAssignment(indexName, docId, deps, requireLocalPrim
   const assignment = requireAssignedPrimary(table.assignments.get(partitionId), indexName, partitionId);
   if (requireLocalPrimary && assignment.primary !== deps.nodeId) {
     throw new NarsilError(
-      ErrorCodes.QUERY_ROUTING_FAILED,
+      ErrorCodes.PARTITION_NOT_PRIMARY,
       `Node '${deps.nodeId}' is not primary for partition ${partitionId} of index '${indexName}'`,
       { indexName, partitionId, primaryNodeId: assignment.primary, localNodeId: deps.nodeId }
     );
   }
   return { partitionId, assignment };
 }
+function assertSufficientActiveReplicas(indexName, partitionId, assignment, deps) {
+  const requiredActiveCopies = deps.waitForActiveReplicas ?? 1;
+  if (requiredActiveCopies <= 1) {
+    return;
+  }
+  const activeCopies = 1 + getInSyncReplicaTargets(assignment, deps.nodeId).length;
+  if (activeCopies < requiredActiveCopies) {
+    throw new NarsilError(
+      ErrorCodes.INSUFFICIENT_REPLICAS,
+      `Write to partition ${partitionId} of index '${indexName}' requires ${requiredActiveCopies} active copies but only ${activeCopies} are available`,
+      { indexName, partitionId, requiredActiveCopies, activeCopies }
+    );
+  }
+}
 function getInSyncReplicaTargets(assignment, localNodeId) {
   const configuredReplicas = new Set(assignment.replicas);
   const targets = [];
@@ -6070,6 +5964,51 @@ function getInSyncReplicaTargets(assignment, localNodeId) {
   }
   return targets;
 }
+async function forwardInsertToRemote(indexName, document, docId, primaryNodeId, deps) {
+  const payload = {
+    indexName,
+    documentId: docId,
+    operation: "insert",
+    document: encode(document),
+    updateFields: null
+  };
+  const message = createForwardMessage(payload, deps.nodeId);
+  const response = await sendToNode(primaryNodeId, message, deps);
+  const decoded = decode(response.payload);
+  if (typeof decoded.documentId !== "string") {
+    throw new NarsilError(
+      ErrorCodes.QUERY_ROUTING_FAILED,
+      `Remote primary returned invalid forward response for index '${indexName}'`,
+      { indexName, primaryNodeId }
+    );
+  }
+  return decoded.documentId;
+}
+async function forwardRemoveToRemote(indexName, docId, primaryNodeId, deps) {
+  const payload = {
+    indexName,
+    documentId: docId,
+    operation: "remove",
+    document: null,
+    updateFields: null
+  };
+  const message = createForwardMessage(payload, deps.nodeId);
+  await sendToNode(primaryNodeId, message, deps);
+}
+async function sendToNode(nodeId, message, deps) {
+  const targets = await resolveNodeTargets(nodeId, deps);
+  let lastError;
+  for (const target of targets) {
+    try {
+      return await deps.transport.send(target, message);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+// src/distribution/cluster-node/write-routing/failures.ts
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -6121,6 +6060,62 @@ async function rollbackPrimaryRemove(indexName, partitionId, documentId, previou
   }
   throwWriteFailure(originalError);
 }
+async function replicateToReplicas(entry, inSyncReplicas, transport, sourceNodeId, resolveNodeTargets3) {
+  const uniqueReplicas = [...new Set(inSyncReplicas)];
+  if (uniqueReplicas.length === 0) {
+    return { acknowledged: [], failed: [] };
+  }
+  const message = createEntryMessage(entry, sourceNodeId);
+  const sendResults = await Promise.allSettled(
+    uniqueReplicas.map((replicaNodeId) => sendToReplica(transport, replicaNodeId, message, resolveNodeTargets3))
+  );
+  const acknowledged = [];
+  const failed = [];
+  for (let i = 0; i < sendResults.length; i++) {
+    const result = sendResults[i];
+    const replicaNodeId = uniqueReplicas[i];
+    if (result.status === "rejected") {
+      if (result.reason instanceof TransportError) {
+        failed.push(replicaNodeId);
+        continue;
+      }
+      throw result.reason;
+    }
+    const response = result.value;
+    if (isMatchingAck(response, entry)) {
+      acknowledged.push(replicaNodeId);
+    } else {
+      failed.push(replicaNodeId);
+    }
+  }
+  return { acknowledged, failed };
+}
+async function sendToReplica(transport, replicaNodeId, message, resolveNodeTargets3) {
+  const targets = resolveNodeTargets3 === void 0 ? [replicaNodeId] : await resolveNodeTargets3(replicaNodeId);
+  const resolvedTargets = targets.length > 0 ? targets : [replicaNodeId];
+  let lastError;
+  for (const target of resolvedTargets) {
+    try {
+      return await transport.send(target, message);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function isMatchingAck(response, entry) {
+  if (response.type !== ReplicationMessageTypes.ACK) {
+    return false;
+  }
+  try {
+    const payload = validateAckPayload(decode(response.payload));
+    return payload.seqNo === entry.seqNo && payload.partitionId === entry.partitionId && payload.indexName === entry.indexName;
+  } catch {
+    return false;
+  }
+}
+
+// src/distribution/cluster-node/write-routing/replication.ts
 async function assertPrimaryWriteAuthority(entry, deps) {
   const table = await deps.coordinator.getAllocation(entry.indexName);
   const currentAssignment = table?.assignments.get(entry.partitionId);
@@ -6130,7 +6125,7 @@ async function assertPrimaryWriteAuthority(entry, deps) {
     return;
   }
   throw new NarsilError(
-    ErrorCodes.QUERY_ROUTING_FAILED,
+    ErrorCodes.PARTITION_NOT_PRIMARY,
     `Primary authority changed before acknowledging write for index '${entry.indexName}' partition ${entry.partitionId}`,
     {
       indexName: entry.indexName,
@@ -6221,7 +6216,10 @@ async function replicateEntry(entry, assignment, deps) {
   await removeFailedReplicasFromInsync(entry, result.failed, deps);
   await assertPrimaryWriteAuthority(entry, deps);
 }
+
+// src/distribution/cluster-node/write-routing/primary-writes.ts
 async function applyPrimaryInsert(indexName, document, docId, partitionId, assignment, deps) {
+  assertSufficientActiveReplicas(indexName, partitionId, assignment, deps);
   const insertedDocId = await deps.engine.insert(indexName, document, docId);
   const storedDocument = await deps.engine.get(indexName, insertedDocId);
   if (storedDocument === void 0) {
@@ -6240,6 +6238,7 @@ async function applyPrimaryInsert(indexName, document, docId, partitionId, assig
   return insertedDocId;
 }
 async function applyPrimaryRemove(indexName, docId, partitionId, assignment, deps) {
+  assertSufficientActiveReplicas(indexName, partitionId, assignment, deps);
   const previousDocument = await deps.engine.get(indexName, docId);
   await deps.engine.remove(indexName, docId);
   try {
@@ -6262,21 +6261,93 @@ async function applyForwardedWrite(payload, deps) {
     if (payload.document === null) {
       throw new NarsilError(ErrorCodes.CONFIG_INVALID, "Invalid ForwardPayload: insert requires a document");
     }
-    const document = decode(payload.document);
-    return applyPrimaryInsert(
-      payload.indexName,
-      document,
-      payload.documentId,
-      resolution.partitionId,
-      resolution.assignment,
-      deps
-    );
-  }
-  if (payload.operation === "remove") {
-    await applyPrimaryRemove(payload.indexName, payload.documentId, resolution.partitionId, resolution.assignment, deps);
-    return payload.documentId;
+    const document = decode(payload.document);
+    return applyPrimaryInsert(
+      payload.indexName,
+      document,
+      payload.documentId,
+      resolution.partitionId,
+      resolution.assignment,
+      deps
+    );
+  }
+  if (payload.operation === "remove") {
+    await applyPrimaryRemove(payload.indexName, payload.documentId, resolution.partitionId, resolution.assignment, deps);
+    return payload.documentId;
+  }
+  throw new NarsilError(ErrorCodes.CONFIG_INVALID, "Forward update operations are not supported yet");
+}
+
+// src/distribution/cluster-node/write-routing/index.ts
+var MAX_REPLICATION_FACTOR = 255;
+function validateCreateIndexOptions(partitionCount, replicationFactor) {
+  if (!Number.isInteger(partitionCount) || partitionCount < 1 || partitionCount > MAX_PARTITION_COUNT) {
+    throw new NarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      `partitionCount must be an integer between 1 and ${MAX_PARTITION_COUNT}, received ${partitionCount}`,
+      { partitionCount }
+    );
+  }
+  if (!Number.isInteger(replicationFactor) || replicationFactor < 0 || replicationFactor > MAX_REPLICATION_FACTOR) {
+    throw new NarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      `replicationFactor must be an integer between 0 and ${MAX_REPLICATION_FACTOR}, received ${replicationFactor}`,
+      { replicationFactor }
+    );
+  }
+}
+async function routeCreateIndex(name, config, options, coordinator, engine) {
+  validateIndexName(name);
+  const partitionCount = options?.partitionCount ?? DEFAULT_PARTITION_COUNT;
+  const replicationFactor = options?.replicationFactor ?? DEFAULT_REPLICATION_FACTOR;
+  validateCreateIndexOptions(partitionCount, replicationFactor);
+  const constraints = {
+    zoneAwareness: false,
+    zoneAttribute: "zone",
+    maxShardsPerNode: null
+  };
+  const metadata = {
+    indexName: name,
+    partitionCount,
+    replicationFactor,
+    constraints
+  };
+  const stored = await putIndexMetadata(coordinator, metadata);
+  if (!stored) {
+    throw new NarsilError(
+      ErrorCodes.INDEX_ALREADY_EXISTS,
+      `Index '${name}' already exists in the cluster or a partial creation is pending`,
+      { indexName: name }
+    );
+  }
+  try {
+    await coordinator.putSchema(name, config.schema);
+    await engine.createIndex(name, config);
+  } catch (createErr) {
+    let cleanupFailed = false;
+    let cleanupError;
+    try {
+      const currentBytes = await coordinator.get(`_narsil/index/${name}/config`);
+      if (currentBytes !== null) {
+        await coordinator.compareAndSet(`_narsil/index/${name}/config`, currentBytes, new Uint8Array(0));
+      }
+    } catch (cleanErr) {
+      cleanupFailed = true;
+      cleanupError = cleanErr;
+    }
+    if (cleanupFailed) {
+      throw new NarsilError(
+        ErrorCodes.CONFIG_INVALID,
+        `Index creation for '${name}' failed and metadata cleanup also failed. The index may be in a partial state and require manual intervention.`,
+        {
+          indexName: name,
+          createError: createErr instanceof Error ? createErr.message : String(createErr),
+          cleanupError: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+        }
+      );
+    }
+    throw createErr;
   }
-  throw new NarsilError(ErrorCodes.CONFIG_INVALID, "Forward update operations are not supported yet");
 }
 async function routeInsert(indexName, document, docId, deps) {
   const resolvedDocId = docId ?? generateId();
@@ -6376,158 +6447,7 @@ async function routeRemoveBatch(indexName, docIds, deps) {
   return { succeeded, failed };
 }
 
-// src/distribution/cluster-node/message-handler.ts
-function createDataNodeHandler(deps) {
-  return async (message, respond) => {
-    if (message.type === ReplicationMessageTypes.SNAPSHOT_SYNC_REQUEST) {
-      await handleSnapshotSyncRequest(message, respond, {
-        nodeId: deps.nodeId,
-        engine: deps.engine,
-        coordinator: deps.coordinator,
-        state: deps.snapshotSyncState,
-        resolveHeaderMetadata: deps.resolveHeaderMetadata
-      });
-      return;
-    }
-    try {
-      switch (message.type) {
-        case ReplicationMessageTypes.SYNC_REQUEST:
-          await handleSyncRequestMessage(message, respond, deps);
-          return;
-        case ReplicationMessageTypes.FORWARD:
-          await handleForward(message, respond, deps);
-          return;
-        case ReplicationMessageTypes.ENTRY:
-          await handleReplicationEntry(message, respond, deps);
-          return;
-        case QueryMessageTypes.SEARCH:
-          await handleSearch(message, respond, deps);
-          return;
-        case QueryMessageTypes.FETCH:
-          await handleFetch(message, respond, deps);
-          return;
-        case QueryMessageTypes.STATS:
-          await handleStats(message, respond, deps);
-          return;
-        default:
-          return;
-      }
-    } catch (err) {
-      const errorPayload = encode({
-        error: true,
-        code: err instanceof NarsilError ? err.code : "INTERNAL_ERROR",
-        message: err instanceof Error ? err.message : String(err)
-      });
-      respond({
-        type: `${message.type}.error`,
-        sourceId: deps.nodeId,
-        requestId: message.requestId,
-        payload: errorPayload
-      });
-    }
-  };
-}
-async function handleSyncRequestMessage(message, respond, deps) {
-  const request = validateSyncRequest(decode(message.payload));
-  const authResult = await authorizeSnapshotRequest(deps.coordinator, request.indexName, message.sourceId);
-  if (authResult.outcome === "denied") {
-    throw new NarsilError(authResult.code, authResult.reason, {
-      indexName: request.indexName,
-      partitionId: request.partitionId,
-      sourceNodeId: message.sourceId
-    });
-  }
-  const table = await deps.coordinator.getAllocation(request.indexName);
-  const assignment = table?.assignments.get(request.partitionId);
-  if (assignment === void 0) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_NOT_ASSIGNED,
-      `No assignment exists for sync request partition ${request.partitionId} of index '${request.indexName}'`,
-      { indexName: request.indexName, partitionId: request.partitionId }
-    );
-  }
-  if (assignment.primary !== deps.nodeId) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_UNAUTHORIZED,
-      `Node '${deps.nodeId}' is not primary for sync request partition ${request.partitionId} of index '${request.indexName}'`,
-      {
-        indexName: request.indexName,
-        partitionId: request.partitionId,
-        localNodeId: deps.nodeId,
-        primaryNodeId: assignment.primary
-      }
-    );
-  }
-  const sourceAssigned = assignment.primary === message.sourceId || assignment.replicas.includes(message.sourceId);
-  if (!sourceAssigned) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_UNAUTHORIZED,
-      `Node '${message.sourceId}' is not assigned to partition ${request.partitionId} of index '${request.indexName}'`,
-      { indexName: request.indexName, partitionId: request.partitionId, sourceNodeId: message.sourceId }
-    );
-  }
-  if (request.lastPrimaryTerm > assignment.primaryTerm) {
-    throw new NarsilError(
-      ErrorCodes.SNAPSHOT_SYNC_REQUEST_INVALID,
-      `Replica term ${request.lastPrimaryTerm} is newer than primary term ${assignment.primaryTerm}`,
-      {
-        indexName: request.indexName,
-        partitionId: request.partitionId,
-        lastPrimaryTerm: request.lastPrimaryTerm,
-        primaryTerm: assignment.primaryTerm
-      }
-    );
-  }
-  const log = deps.writeDeps.getReplicationLog(request.indexName, request.partitionId);
-  const tier = decideSyncTier(log, request.lastSeqNo);
-  if (tier === "incremental") {
-    sendSyncEntriesResponse(message, respond, deps, log.getEntriesFrom(request.lastSeqNo + 1));
-    return;
-  }
-  const snapshotSeqNo = log.committedSeqNo;
-  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) };
-      },
-      afterSnapshot: (trailingSink) => {
-        const entries = log.getEntriesFrom(snapshotSeqNo + 1);
-        sendSyncEntriesResponse(message, trailingSink, deps, entries);
-      }
-    }
-  );
-}
-function sendSyncEntriesResponse(message, respond, deps, entries) {
-  const payload = {
-    entries,
-    isLast: true
-  };
-  respond({
-    type: ReplicationMessageTypes.SYNC_ENTRIES,
-    sourceId: deps.nodeId,
-    requestId: message.requestId,
-    payload: encode(payload)
-  });
-}
+// src/distribution/cluster-node/message-handler/writes.ts
 async function handleForward(message, respond, deps) {
   const decoded = decode(message.payload);
   const payload = validateForwardPayload(decoded);
@@ -6572,7 +6492,7 @@ async function handleReplicationEntry(message, respond, deps) {
   }
   if (assignment.primaryTerm !== entry.primaryTerm) {
     throw new NarsilError(
-      ErrorCodes.REPLICATION_ENTRY_INVALID,
+      ErrorCodes.REPLICATION_TERM_MISMATCH,
       `Replication entry term ${entry.primaryTerm} does not match allocation term ${assignment.primaryTerm}`,
       { indexName: entry.indexName, partitionId: entry.partitionId }
     );
@@ -6591,118 +6511,36 @@ async function handleReplicationEntry(message, respond, deps) {
       throw new NarsilError(
         ErrorCodes.REPLICATION_ENTRY_INVALID,
         `Conflicting replication entry at sequence number ${entry.seqNo}`,
-        { indexName: entry.indexName, partitionId: entry.partitionId, seqNo: entry.seqNo }
-      );
-    }
-    respond(createAckMessage(entry.seqNo, entry.partitionId, entry.indexName, deps.nodeId, message.requestId));
-    return;
-  }
-  const expectedSeqNo = (log.newestSeqNo ?? 0) + 1;
-  if (entry.seqNo !== expectedSeqNo) {
-    const canSeedFromCompletedBootstrap = log.entryCount === 0 && entry.seqNo > expectedSeqNo && deps.isBootstrapSynced?.(entry.indexName, entry.partitionId) === true;
-    if (!canSeedFromCompletedBootstrap) {
-      throw new NarsilError(
-        ErrorCodes.REPLICATION_ENTRY_INVALID,
-        `Out-of-order replication entry ${entry.seqNo}; expected ${expectedSeqNo}`,
-        { indexName: entry.indexName, partitionId: entry.partitionId, seqNo: entry.seqNo, expectedSeqNo }
-      );
-    }
-    deps.writeDeps.resetReplicationLog(entry.indexName, entry.partitionId, entry.seqNo, entry.primaryTerm);
-    log = deps.writeDeps.getReplicationLog(entry.indexName, entry.partitionId);
-  }
-  const validation = validateReplicationEntry(entry, assignment.primaryTerm, log);
-  if (!validation.valid) {
-    throw new NarsilError(
-      ErrorCodes.REPLICATION_ENTRY_INVALID,
-      `Invalid replication entry ${entry.seqNo}: ${validation.error ?? "unknown validation error"}`,
-      { indexName: entry.indexName, partitionId: entry.partitionId, seqNo: entry.seqNo }
-    );
-  }
-  await deps.engine.applyReplicationEntry(entry);
-  log.appendCommitted(entry);
-  respond(createAckMessage(entry.seqNo, entry.partitionId, entry.indexName, deps.nodeId, message.requestId));
-}
-async function handleSearch(message, respond, deps) {
-  const decoded = decode(message.payload);
-  const payload = validateSearchPayload(decoded);
-  const queryParams = {
-    term: payload.params.term ?? void 0,
-    fields: payload.params.fields ?? void 0,
-    filters: payload.params.filters ?? void 0,
-    boost: payload.params.boost ?? void 0,
-    scoring: payload.params.scoring,
-    tolerance: payload.params.tolerance ?? void 0,
-    minScore: payload.params.threshold ?? void 0,
-    limit: payload.params.limit,
-    offset: payload.params.offset,
-    searchAfter: payload.params.searchAfter ?? void 0,
-    sort: convertWireSortToLocal(payload.params.sort),
-    group: payload.params.group !== null ? { fields: [payload.params.group.field], maxPerGroup: payload.params.group.maxPerGroup } : void 0,
-    facets: convertWireFacetsToLocal(payload.params.facets, payload.facetShardSize ?? payload.params.facetSize),
-    vector: payload.params.vector !== null ? {
-      field: payload.params.vector.field,
-      value: payload.params.vector.value ?? void 0,
-      text: payload.params.vector.text ?? void 0,
-      similarity: payload.params.vector.similarity ?? void 0
-    } : void 0,
-    hybrid: payload.params.hybrid !== null ? { strategy: payload.params.hybrid.strategy, k: payload.params.hybrid.k, alpha: payload.params.hybrid.alpha } : void 0
-  };
-  const queryResult = await deps.engine.query(payload.indexName, queryParams);
-  const scored = queryResult.hits.map((hit) => ({
-    docId: hit.id,
-    score: hit.score,
-    sortValues: null
-  }));
-  const results = payload.partitionIds.map((partitionId) => ({
-    partitionId,
-    scored: partitionId === payload.partitionIds[0] ? scored : [],
-    totalHits: partitionId === payload.partitionIds[0] ? queryResult.count : 0
-  }));
-  const resultPayload = { results, facets: convertLocalFacetsToWire(queryResult.facets) };
-  respond({
-    type: QueryMessageTypes.SEARCH_RESULT,
-    sourceId: deps.nodeId,
-    requestId: message.requestId,
-    payload: encode(resultPayload)
-  });
-}
-async function handleFetch(message, respond, deps) {
-  const decoded = decode(message.payload);
-  const payload = validateFetchPayload(decoded);
-  const documents = [];
-  for (const docRef of payload.documentIds) {
-    const doc = await deps.engine.get(payload.indexName, docRef.docId);
-    if (doc !== void 0) {
-      documents.push({
-        docId: docRef.docId,
-        document: doc,
-        highlights: null
-      });
+        { indexName: entry.indexName, partitionId: entry.partitionId, seqNo: entry.seqNo }
+      );
     }
+    respond(createAckMessage(entry.seqNo, entry.partitionId, entry.indexName, deps.nodeId, message.requestId));
+    return;
   }
-  const resultPayload = { documents };
-  respond({
-    type: QueryMessageTypes.FETCH_RESULT,
-    sourceId: deps.nodeId,
-    requestId: message.requestId,
-    payload: encode(resultPayload)
-  });
-}
-async function handleStats(message, respond, deps) {
-  const decoded = decode(message.payload);
-  const payload = validateStatsPayload(decoded);
-  const stats = deps.engine.getStats(payload.indexName);
-  const resultPayload = {
-    totalDocuments: stats.documentCount,
-    docFrequencies: {},
-    totalFieldLengths: {}
-  };
-  respond({
-    type: QueryMessageTypes.STATS_RESULT,
-    sourceId: deps.nodeId,
-    requestId: message.requestId,
-    payload: encode(resultPayload)
-  });
+  const expectedSeqNo = (log.newestSeqNo ?? 0) + 1;
+  if (entry.seqNo !== expectedSeqNo) {
+    const canSeedFromCompletedBootstrap = log.entryCount === 0 && entry.seqNo > expectedSeqNo && deps.isBootstrapSynced?.(entry.indexName, entry.partitionId) === true;
+    if (!canSeedFromCompletedBootstrap) {
+      throw new NarsilError(
+        ErrorCodes.REPLICATION_ENTRY_INVALID,
+        `Out-of-order replication entry ${entry.seqNo}; expected ${expectedSeqNo}`,
+        { indexName: entry.indexName, partitionId: entry.partitionId, seqNo: entry.seqNo, expectedSeqNo }
+      );
+    }
+    deps.writeDeps.resetReplicationLog(entry.indexName, entry.partitionId, entry.seqNo, entry.primaryTerm);
+    log = deps.writeDeps.getReplicationLog(entry.indexName, entry.partitionId);
+  }
+  const validation = validateReplicationEntry(entry, assignment.primaryTerm, log);
+  if (!validation.valid) {
+    throw new NarsilError(
+      validation.error ?? ErrorCodes.REPLICATION_ENTRY_INVALID,
+      `Invalid replication entry ${entry.seqNo}`,
+      { indexName: entry.indexName, partitionId: entry.partitionId, seqNo: entry.seqNo }
+    );
+  }
+  await deps.engine.applyReplicationEntry(entry);
+  log.appendCommitted(entry);
+  respond(createAckMessage(entry.seqNo, entry.partitionId, entry.indexName, deps.nodeId, message.requestId));
 }
 function validateForwardPayload(decoded) {
   if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) {
@@ -6723,35 +6561,127 @@ function validateForwardPayload(decoded) {
   }
   return decoded;
 }
-function convertWireSortToLocal(wireSort) {
-  if (wireSort === null || wireSort.length === 0) {
-    return void 0;
-  }
-  const result = {};
-  for (const entry of wireSort) {
-    result[entry.field] = entry.direction;
-  }
-  return result;
+
+// src/distribution/cluster-node/message-handler/index.ts
+function createDataNodeHandler(deps) {
+  return async (message, respond) => {
+    if (message.type === ReplicationMessageTypes.SNAPSHOT_SYNC_REQUEST) {
+      await handleSnapshotSyncRequest(message, respond, {
+        nodeId: deps.nodeId,
+        engine: deps.engine,
+        coordinator: deps.coordinator,
+        state: deps.snapshotSyncState,
+        resolveHeaderMetadata: deps.resolveHeaderMetadata
+      });
+      return;
+    }
+    try {
+      switch (message.type) {
+        case ReplicationMessageTypes.SYNC_REQUEST:
+          await handleSyncRequestMessage(message, respond, deps);
+          return;
+        case ReplicationMessageTypes.FORWARD:
+          await handleForward(message, respond, deps);
+          return;
+        case ReplicationMessageTypes.ENTRY:
+          await handleReplicationEntry(message, respond, deps);
+          return;
+        case QueryMessageTypes.SEARCH:
+          await handleSearch(message, respond, deps);
+          return;
+        case QueryMessageTypes.FETCH:
+          await handleFetch(message, respond, deps);
+          return;
+        case QueryMessageTypes.STATS:
+          await handleStats(message, respond, deps);
+          return;
+        default:
+          return;
+      }
+    } catch (err) {
+      const errorPayload = encode({
+        error: true,
+        code: err instanceof NarsilError ? err.code : "INTERNAL_ERROR",
+        message: err instanceof Error ? err.message : String(err)
+      });
+      respond({
+        type: `${message.type}.error`,
+        sourceId: deps.nodeId,
+        requestId: message.requestId,
+        payload: errorPayload
+      });
+    }
+  };
 }
-function convertWireFacetsToLocal(facets, limit) {
-  if (facets === null || facets.length === 0) {
-    return void 0;
+async function resolveNodeTargets2(config, targetNodeId) {
+  const targets = [targetNodeId];
+  const nodes = await config.coordinator.listNodes();
+  const registration = nodes.find((node) => node.nodeId === targetNodeId);
+  if (registration !== void 0 && registration.address.length > 0 && registration.address !== targetNodeId) {
+    targets.push(registration.address);
   }
-  const result = {};
-  for (const field of facets) {
-    result[field] = limit !== null ? { limit } : {};
+  return targets;
+}
+async function sendToNode2(config, targetNodeId, message) {
+  const targets = await resolveNodeTargets2(config, targetNodeId);
+  let lastError;
+  for (const target of targets) {
+    try {
+      return await config.transport.send(target, message);
+    } catch (error) {
+      lastError = error;
+    }
   }
-  return result;
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
-function convertLocalFacetsToWire(facets) {
-  if (facets === void 0) {
-    return null;
+async function fetchDistributedDocuments(config, nodeId, engine, indexName, result, allocation) {
+  const partitionCount = allocation.assignments.size;
+  const nodeToDocumentIds = /* @__PURE__ */ new Map();
+  for (const entry of result.scored) {
+    const partitionId = resolvePartitionId(entry.docId, partitionCount);
+    const assignment = allocation.assignments.get(partitionId);
+    if (assignment === void 0) {
+      continue;
+    }
+    const selectedNodeId = selectReplica(assignment, nodeId, void 0, partitionId);
+    if (selectedNodeId === null) {
+      continue;
+    }
+    let documentIds = nodeToDocumentIds.get(selectedNodeId);
+    if (documentIds === void 0) {
+      documentIds = [];
+      nodeToDocumentIds.set(selectedNodeId, documentIds);
+    }
+    documentIds.push({ docId: entry.docId, partitionId });
   }
-  const result = {};
-  for (const [field, facet] of Object.entries(facets)) {
-    result[field] = Object.entries(facet.values).map(([value, count]) => ({ value, count }));
+  const documents = /* @__PURE__ */ new Map();
+  for (const [targetNodeId, documentIds] of nodeToDocumentIds) {
+    if (targetNodeId === nodeId) {
+      for (const { docId } of documentIds) {
+        const document = await engine.get(indexName, docId);
+        if (document !== void 0) {
+          documents.set(docId, document);
+        }
+      }
+      continue;
+    }
+    const fetchMessage = createFetchMessage(
+      {
+        indexName,
+        documentIds,
+        fields: null,
+        highlight: null
+      },
+      nodeId
+    );
+    const response = await sendToNode2(config, targetNodeId, fetchMessage);
+    const decoded = decode(response.payload);
+    const payload = validateFetchResultPayload(decoded);
+    for (const fetched of payload.documents) {
+      documents.set(fetched.docId, fetched.document);
+    }
   }
-  return result;
+  return documents;
 }
 
 // src/distribution/cluster-node/query-conversion.ts
@@ -6798,50 +6728,275 @@ function convertLocalGroupToWire(group) {
   if (group === void 0) {
     return null;
   }
-  return {
-    field: group.fields[0],
-    maxPerGroup: group.maxPerGroup ?? 1
-  };
-}
-function convertLocalFacetsToWire2(facets) {
-  if (facets === void 0) {
-    return null;
+  return {
+    field: group.fields[0],
+    maxPerGroup: group.maxPerGroup ?? 1
+  };
+}
+function convertLocalFacetsToWire2(facets) {
+  if (facets === void 0) {
+    return null;
+  }
+  return Object.keys(facets);
+}
+function convertLocalVectorToWire(vector) {
+  if (vector === void 0) {
+    return null;
+  }
+  return {
+    field: vector.field,
+    value: vector.value ?? null,
+    text: vector.text ?? null,
+    similarity: vector.similarity ?? null
+  };
+}
+function convertLocalHybridToWire(hybrid) {
+  if (hybrid === void 0) {
+    return null;
+  }
+  return {
+    strategy: hybrid.strategy ?? "rrf",
+    k: hybrid.k ?? 60,
+    alpha: hybrid.alpha ?? 0.5
+  };
+}
+function convertWireFacetsToLocal2(wireFacets) {
+  const result = {};
+  for (const [field, buckets] of Object.entries(wireFacets)) {
+    const values = {};
+    let totalCount = 0;
+    for (const bucket of buckets) {
+      values[bucket.value] = bucket.count;
+      totalCount += bucket.count;
+    }
+    result[field] = { values, count: totalCount };
+  }
+  return result;
+}
+
+// src/distribution/replication/types.ts
+var DEFAULT_LOG_RETENTION_BYTES = 268435456;
+
+// src/distribution/replication/log.ts
+var ENTRY_FIXED_OVERHEAD_BYTES = 40;
+function estimateEntrySize(entry) {
+  return ENTRY_FIXED_OVERHEAD_BYTES + 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 committedSeqNo = nextSeqNo - 1;
+  let committedPrimaryTerm = config?.lastPrimaryTerm ?? 0;
+  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_BYTES + 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 >= committedSeqNo) {
+      committedSeqNo = entry.seqNo;
+      committedPrimaryTerm = 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;
   }
-  return Object.keys(facets);
-}
-function convertLocalVectorToWire(vector) {
-  if (vector === void 0) {
-    return null;
+  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 {
-    field: vector.field,
-    value: vector.value ?? null,
-    text: vector.text ?? null,
-    similarity: vector.similarity ?? null
+    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 committedSeqNo() {
+      return committedSeqNo;
+    },
+    get committedPrimaryTerm() {
+      return committedPrimaryTerm;
+    },
+    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;
+      committedSeqNo = nextSeqNo - 1;
+    }
   };
 }
-function convertLocalHybridToWire(hybrid) {
-  if (hybrid === void 0) {
-    return null;
-  }
-  return {
-    strategy: hybrid.strategy ?? "rrf",
-    k: hybrid.k ?? 60,
-    alpha: hybrid.alpha ?? 0.5
-  };
+
+// src/distribution/cluster-node/replication-logs.ts
+function replicationLogKey(indexName, partitionId) {
+  return `${indexName}:${partitionId}`;
 }
-function convertWireFacetsToLocal2(wireFacets) {
-  const result = {};
-  for (const [field, buckets] of Object.entries(wireFacets)) {
-    const values = {};
-    let totalCount = 0;
-    for (const bucket of buckets) {
-      values[bucket.value] = bucket.count;
-      totalCount += bucket.count;
-    }
-    result[field] = { values, count: totalCount };
-  }
-  return result;
+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);
+  }
+  return log;
+}
+function seedReplicationLog(replicationLogs, indexName, partitionId, startSeqNo, lastPrimaryTerm = 0, replicationConfig) {
+  replicationLogs.set(
+    replicationLogKey(indexName, partitionId),
+    createReplicationLog(partitionId, {
+      startSeqNo,
+      lastPrimaryTerm,
+      logRetentionBytes: replicationConfig?.logRetentionBytes
+    })
+  );
 }
 
 // src/distribution/cluster-node/transport-listener.ts
@@ -6897,6 +7052,53 @@ function createSingleResponseRespond(respond) {
   };
 }
 
+// src/distribution/cluster-node/validate-config.ts
+var MAX_WAIT_FOR_ACTIVE_REPLICAS = 255;
+function validateClusterNodeConfig(config) {
+  if (config.address.length === 0) {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "ClusterNodeConfig.address must not be empty");
+  }
+  if (config.roles !== void 0) {
+    if (config.roles.length === 0) {
+      throw new NarsilError(ErrorCodes.CONFIG_INVALID, "ClusterNodeConfig.roles must contain at least one role");
+    }
+    const validRoles = /* @__PURE__ */ new Set(["data", "coordinator", "controller"]);
+    for (const role of config.roles) {
+      if (!validRoles.has(role)) {
+        throw new NarsilError(ErrorCodes.CONFIG_INVALID, `Invalid role: '${role}'`, { role });
+      }
+    }
+  }
+  if (config.capacity !== void 0) {
+    if (config.capacity.memoryBytes <= 0 || !Number.isFinite(config.capacity.memoryBytes)) {
+      throw new NarsilError(
+        ErrorCodes.CONFIG_INVALID,
+        "ClusterNodeConfig.capacity.memoryBytes must be a positive finite number"
+      );
+    }
+    if (config.capacity.cpuCores <= 0 || !Number.isInteger(config.capacity.cpuCores)) {
+      throw new NarsilError(ErrorCodes.CONFIG_INVALID, "ClusterNodeConfig.capacity.cpuCores must be a positive integer");
+    }
+  }
+  if (config.replication !== void 0) {
+    const { logRetentionBytes, waitForActiveReplicas } = config.replication;
+    if (logRetentionBytes !== void 0 && (!Number.isInteger(logRetentionBytes) || logRetentionBytes <= 0)) {
+      throw new NarsilError(
+        ErrorCodes.CONFIG_INVALID,
+        "ClusterNodeConfig.replication.logRetentionBytes must be a positive integer",
+        { logRetentionBytes }
+      );
+    }
+    if (waitForActiveReplicas !== void 0 && (!Number.isInteger(waitForActiveReplicas) || waitForActiveReplicas < 1 || waitForActiveReplicas > MAX_WAIT_FOR_ACTIVE_REPLICAS)) {
+      throw new NarsilError(
+        ErrorCodes.CONFIG_INVALID,
+        `ClusterNodeConfig.replication.waitForActiveReplicas must be an integer between 1 and ${MAX_WAIT_FOR_ACTIVE_REPLICAS}`,
+        { waitForActiveReplicas }
+      );
+    }
+  }
+}
+
 // src/distribution/cluster-node/index.ts
 var SPEC_VERSION = "1.0";
 async function createClusterNode(config) {
@@ -6908,6 +7110,21 @@ async function createClusterNode(config) {
   const bootstrapSyncState = createBootstrapSyncState();
   const snapshotSyncHandlerState = createSnapshotSyncHandlerState();
   const replicationLogs = /* @__PURE__ */ new Map();
+  function replicationLogKey2(indexName, partitionId) {
+    return replicationLogKey(indexName, partitionId);
+  }
+  function getReplicationLog2(indexName, partitionId) {
+    return getReplicationLog(replicationLogs, indexName, partitionId, config.replication);
+  }
+  function seedReplicationLog2(indexName, partitionId, startSeqNo, lastPrimaryTerm = 0) {
+    seedReplicationLog(replicationLogs, indexName, partitionId, startSeqNo, lastPrimaryTerm, config.replication);
+  }
+  async function resolveNodeTargets3(targetNodeId) {
+    return resolveNodeTargets2(config, targetNodeId);
+  }
+  async function fetchDistributedDocuments2(indexName, result, allocation) {
+    return fetchDistributedDocuments(config, nodeId, engine, indexName, result, allocation);
+  }
   const forwardOnError = (error) => {
     if (config.onError === void 0) {
       return;
@@ -6931,9 +7148,10 @@ async function createClusterNode(config) {
     coordinator: config.coordinator,
     engine,
     transport: config.transport,
-    getReplicationLog,
-    resetReplicationLog: seedReplicationLog,
-    resolveNodeTargets: resolveNodeTargets2
+    getReplicationLog: getReplicationLog2,
+    resetReplicationLog: seedReplicationLog2,
+    resolveNodeTargets: resolveNodeTargets3,
+    waitForActiveReplicas: config.replication?.waitForActiveReplicas
   };
   let lifecycle = null;
   let controller = null;
@@ -6956,16 +7174,16 @@ async function createClusterNode(config) {
         coordinator: config.coordinator,
         transport: config.transport,
         sourceNodeId: nodeId,
-        resolveNodeTargets: resolveNodeTargets2,
-        getReplicationLog,
-        resetReplicationLog: seedReplicationLog,
+        resolveNodeTargets: resolveNodeTargets3,
+        getReplicationLog: getReplicationLog2,
+        resetReplicationLog: seedReplicationLog2,
         applyReplicationEntry: engine.applyReplicationEntry,
         restoreReplicationPartition: engine.restoreReplicationPartition,
         onError: forwardOnError
       }),
       onRemovePartition: (indexName, partitionId) => {
         clearBootstrapSyncIndex(bootstrapSyncState, indexName, partitionId);
-        replicationLogs.delete(replicationLogKey(indexName, partitionId));
+        replicationLogs.delete(replicationLogKey2(indexName, partitionId));
         void cleanupRemovedPartition(indexName, partitionId, {
           engine,
           coordinator: config.coordinator,
@@ -7061,10 +7279,10 @@ async function createClusterNode(config) {
           transport: config.transport,
           sourceNodeId: nodeId,
           getAllocation: (idx) => config.coordinator.getAllocation(idx),
-          resolveNodeTargets: resolveNodeTargets2
+          resolveNodeTargets: resolveNodeTargets3
         };
         const distributed = await distributedQuery(indexName, wireParams, queryDeps);
-        const documents = await fetchDistributedDocuments(indexName, distributed, allocation);
+        const documents = await fetchDistributedDocuments2(indexName, distributed, allocation);
         return distributedResultToLocal(distributed, documents);
       });
     },
@@ -7115,24 +7333,6 @@ async function createClusterNode(config) {
     }
   };
   return node;
-  function replicationLogKey(indexName, partitionId) {
-    return `${indexName}:${partitionId}`;
-  }
-  function getReplicationLog(indexName, partitionId) {
-    const key = replicationLogKey(indexName, partitionId);
-    let log = replicationLogs.get(key);
-    if (log === void 0) {
-      log = createReplicationLog(partitionId);
-      replicationLogs.set(key, log);
-    }
-    return log;
-  }
-  function seedReplicationLog(indexName, partitionId, startSeqNo, lastPrimaryTerm = 0) {
-    replicationLogs.set(
-      replicationLogKey(indexName, partitionId),
-      createReplicationLog(partitionId, { startSeqNo, lastPrimaryTerm })
-    );
-  }
   async function resolveSnapshotHeaderMetadata(indexName, partitionId) {
     const fallback = await defaultSnapshotHeaderMetadataProvider(config.coordinator, indexName);
     if (partitionId === null) {
@@ -7140,110 +7340,13 @@ async function createClusterNode(config) {
     }
     const allocation = await config.coordinator.getAllocation(indexName);
     const assignment = allocation?.assignments.get(partitionId);
-    const log = getReplicationLog(indexName, partitionId);
+    const log = getReplicationLog2(indexName, partitionId);
     return {
       partitionId,
       primaryTerm: assignment?.primaryTerm ?? fallback.primaryTerm,
       lastSeqNo: log.newestSeqNo ?? 0
     };
   }
-  async function resolveNodeTargets2(targetNodeId) {
-    const targets = [targetNodeId];
-    const nodes = await config.coordinator.listNodes();
-    const registration2 = nodes.find((node2) => node2.nodeId === targetNodeId);
-    if (registration2 !== void 0 && registration2.address.length > 0 && registration2.address !== targetNodeId) {
-      targets.push(registration2.address);
-    }
-    return targets;
-  }
-  async function fetchDistributedDocuments(indexName, result, allocation) {
-    const partitionCount = allocation.assignments.size;
-    const nodeToDocumentIds = /* @__PURE__ */ new Map();
-    for (const entry of result.scored) {
-      const partitionId = resolvePartitionId(entry.docId, partitionCount);
-      const assignment = allocation.assignments.get(partitionId);
-      if (assignment === void 0) {
-        continue;
-      }
-      const selectedNodeId = selectReplica(assignment, nodeId, void 0, partitionId);
-      if (selectedNodeId === null) {
-        continue;
-      }
-      let documentIds = nodeToDocumentIds.get(selectedNodeId);
-      if (documentIds === void 0) {
-        documentIds = [];
-        nodeToDocumentIds.set(selectedNodeId, documentIds);
-      }
-      documentIds.push({ docId: entry.docId, partitionId });
-    }
-    const documents = /* @__PURE__ */ new Map();
-    for (const [targetNodeId, documentIds] of nodeToDocumentIds) {
-      if (targetNodeId === nodeId) {
-        for (const { docId } of documentIds) {
-          const document = await engine.get(indexName, docId);
-          if (document !== void 0) {
-            documents.set(docId, document);
-          }
-        }
-        continue;
-      }
-      const fetchMessage = createFetchMessage(
-        {
-          indexName,
-          documentIds,
-          fields: null,
-          highlight: null
-        },
-        nodeId
-      );
-      const response = await sendToNode2(targetNodeId, fetchMessage);
-      const decoded = decode(response.payload);
-      const payload = validateFetchResultPayload(decoded);
-      for (const fetched of payload.documents) {
-        documents.set(fetched.docId, fetched.document);
-      }
-    }
-    return documents;
-  }
-  async function sendToNode2(targetNodeId, message) {
-    const targets = await resolveNodeTargets2(targetNodeId);
-    let lastError;
-    for (const target of targets) {
-      try {
-        return await config.transport.send(target, message);
-      } catch (error) {
-        lastError = error;
-      }
-    }
-    throw lastError instanceof Error ? lastError : new Error(String(lastError));
-  }
-}
-function validateClusterNodeConfig(config) {
-  if (config.address.length === 0) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "ClusterNodeConfig.address must not be empty");
-  }
-  if (config.roles !== void 0) {
-    if (config.roles.length === 0) {
-      throw new NarsilError(ErrorCodes.CONFIG_INVALID, "ClusterNodeConfig.roles must contain at least one role");
-    }
-    const validRoles = /* @__PURE__ */ new Set(["data", "coordinator", "controller"]);
-    for (const role of config.roles) {
-      if (!validRoles.has(role)) {
-        throw new NarsilError(ErrorCodes.CONFIG_INVALID, `Invalid role: '${role}'`, { role });
-      }
-    }
-  }
-  if (config.capacity !== void 0) {
-    if (config.capacity.memoryBytes <= 0 || !Number.isFinite(config.capacity.memoryBytes)) {
-      throw new NarsilError(
-        ErrorCodes.CONFIG_INVALID,
-        "ClusterNodeConfig.capacity.memoryBytes must be a positive finite number"
-      );
-    }
-    if (config.capacity.cpuCores <= 0 || !Number.isInteger(config.capacity.cpuCores)) {
-      throw new NarsilError(ErrorCodes.CONFIG_INVALID, "ClusterNodeConfig.capacity.cpuCores must be a positive integer");
-    }
-  }
 }
 
 // src/distribution/transport/in-memory.ts