@delali/narsil 0.2.3-next.32 → 0.2.3-next.34

package/dist/distribution.mjs

@@ -1,5 +1,5 @@
-import { createEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, now, validateIndexName, indexConfigKey, putIndexMetadata, getIndexMetadata, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, MAX_PARTITION_COUNT, clampLimit, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, MAX_SUGGEST_SCATTER_LIMIT, chunkByBudget, WIRE_BATCH_BUDGET, MAX_INDEX_NAME_LENGTH, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, createEntryMessage, computeEntryChecksum, createInsyncConfirmMessage, createEntryBatchMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload } from './chunk-TEAJO7CU.mjs';
-import { ReplicationMessageTypes, ClusterMessageTypes, QueryMessageTypes, TransportError, MAX_MESSAGE_SIZE_BYTES } from './chunk-C6VVLMRX.mjs';
+import { createEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, now, validateIndexName, indexConfigKey, putIndexMetadata, getIndexMetadata, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, MAX_PARTITION_COUNT, clampLimit, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, MAX_SUGGEST_SCATTER_LIMIT, chunkByBudget, WIRE_BATCH_BUDGET, MAX_INDEX_NAME_LENGTH, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, createEntryMessage, computeEntryChecksum, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-GN7KF675.mjs';
+import { ReplicationMessageTypes, ClusterMessageTypes, QueryMessageTypes, TransportError, MAX_MESSAGE_SIZE_BYTES } from './chunk-36ER4WCG.mjs';
 import { deserializePayloadV2, createPartitionIndex, resolveProjection, clampRowCount, sortSignatureOf, requireMatchingCursor, decodePageCursor, normalizeSort, encodePageCursor, applyProjection, readSortValues, getLanguage, DEFAULT_PAGE_SIZE, requireWithinResultWindow, fnv1a, FILTER_EXPRESSION_KEYS, MAX_CURSOR_LENGTH, mergePartitionStats, FIELD_FILTER_OPERATORS, MAX_NESTING_DEPTH } from './chunk-RO4EFWE6.mjs';
 import './chunk-TGP5M5R7.mjs';
 import './chunk-OBXS7OZM.mjs';
@@ -60,61 +60,6 @@ function startRenewalInterval(state, coordinator, nodeId, ttlMs, onLeaseLost) {
 function scheduleStandbyRetry(state, retryMs, onRetry) {
   state.standbyTimer = setTimeout(onRetry, retryMs);
 }
-async function requestInsyncRemoval(indexName, partitionId, replicaNodeId, primaryTerm, controllerNodeId, transport, sourceNodeId) {
-  const payload = {
-    indexName,
-    partitionId,
-    replicaNodeId,
-    primaryTerm
-  };
-  const message = createInsyncRemoveMessage(payload, sourceNodeId);
-  const response = await transport.send(controllerNodeId, message);
-  const confirmPayload = validateInsyncConfirmPayload(decode(response.payload));
-  return { accepted: confirmPayload.accepted };
-}
-async function handleInsyncRemoval(payload, coordinator) {
-  const table = await coordinator.getAllocation(payload.indexName);
-  if (table === null) {
-    return {
-      indexName: payload.indexName,
-      partitionId: payload.partitionId,
-      accepted: false
-    };
-  }
-  const assignment = table.assignments.get(payload.partitionId);
-  if (assignment === void 0) {
-    return {
-      indexName: payload.indexName,
-      partitionId: payload.partitionId,
-      accepted: false
-    };
-  }
-  if (payload.primaryTerm !== assignment.primaryTerm) {
-    return {
-      indexName: payload.indexName,
-      partitionId: payload.partitionId,
-      accepted: false
-    };
-  }
-  const updatedInSyncSet = assignment.inSyncSet.filter((nodeId) => nodeId !== payload.replicaNodeId);
-  const updatedAssignment = {
-    ...assignment,
-    inSyncSet: updatedInSyncSet
-  };
-  const updatedAssignments = new Map(table.assignments);
-  updatedAssignments.set(payload.partitionId, updatedAssignment);
-  const updatedTable = {
-    ...table,
-    version: table.version + 1,
-    assignments: updatedAssignments
-  };
-  const written = await coordinator.putAllocation(payload.indexName, updatedTable, table.version);
-  return {
-    indexName: payload.indexName,
-    partitionId: payload.partitionId,
-    accepted: written
-  };
-}
 
 // src/distribution/cluster/allocator/deciders/balance.ts
 var balanceDecider = {
@@ -392,6 +337,7 @@ function initialAllocate(nodes, indexName, partitionCount, replicationFactor, co
       primary: primaryNodeId,
       replicas,
       inSyncSet: [],
+      commitPoint: 0,
       state: "INITIALISING",
       primaryTerm: 1
     };
@@ -442,6 +388,7 @@ function cloneAssignments(assignments) {
       primary: assignment.primary,
       replicas: [...assignment.replicas],
       inSyncSet: [...assignment.inSyncSet],
+      commitPoint: assignment.commitPoint,
       state: assignment.state,
       primaryTerm: assignment.primaryTerm
     });
@@ -613,203 +560,14 @@ function allocate(nodes, currentTable, indexName, partitionCount, replicationFac
   }
   return rebalanceAllocate(dataNodes, currentTable, constraints, deciders);
 }
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isValidInteger(value) {
-  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
-}
-function validateBootstrapCompletePayload(decoded) {
-  if (!isRecord(decoded)) {
-    return null;
-  }
-  if (typeof decoded.indexName !== "string" || decoded.indexName.length === 0) {
-    return null;
-  }
-  if (!isValidInteger(decoded.partitionId) || decoded.partitionId < 0) {
-    return null;
-  }
-  if (typeof decoded.nodeId !== "string") {
-    return null;
-  }
-  if (!isValidInteger(decoded.primaryTerm)) {
-    return null;
-  }
-  return {
-    indexName: decoded.indexName,
-    partitionId: decoded.partitionId,
-    nodeId: decoded.nodeId,
-    primaryTerm: decoded.primaryTerm
-  };
-}
-async function sendRejection(respond, controllerNodeId, requestId, indexName, partitionId) {
-  const resultPayload = {
-    indexName,
-    partitionId,
-    accepted: false
-  };
-  const response = {
-    type: ClusterMessageTypes.BOOTSTRAP_COMPLETE,
-    sourceId: controllerNodeId,
-    requestId,
-    payload: encode(resultPayload)
-  };
-  await respond(response);
-}
-function handleBootstrapCompleteMessage(message, respond, coordinator, controllerNodeId) {
-  let decoded;
-  try {
-    decoded = decode(message.payload);
-  } catch (_) {
-    void sendRejection(respond, controllerNodeId, message.requestId, "", -1);
-    return;
-  }
-  const payload = validateBootstrapCompletePayload(decoded);
-  if (payload === null) {
-    void sendRejection(respond, controllerNodeId, message.requestId, "", -1);
-    return;
-  }
-  if (message.sourceId !== payload.nodeId) {
-    void sendRejection(respond, controllerNodeId, message.requestId, payload.indexName, payload.partitionId);
-    return;
-  }
-  processBootstrapComplete(payload, coordinator).then(async (accepted) => {
-    const resultPayload = {
-      indexName: payload.indexName,
-      partitionId: payload.partitionId,
-      accepted
-    };
-    const response = {
-      type: ClusterMessageTypes.BOOTSTRAP_COMPLETE,
-      sourceId: controllerNodeId,
-      requestId: message.requestId,
-      payload: encode(resultPayload)
-    };
-    await respond(response);
-  }).catch(() => sendRejection(respond, controllerNodeId, message.requestId, payload.indexName, payload.partitionId));
-}
-function ensurePrimaryInSyncSet(assignment, inSyncSet) {
-  if (assignment.primary === null) {
-    return inSyncSet;
-  }
-  if (inSyncSet.includes(assignment.primary)) {
-    return inSyncSet;
-  }
-  return [assignment.primary, ...inSyncSet];
-}
-async function processBootstrapComplete(payload, coordinator) {
-  const table = await coordinator.getAllocation(payload.indexName);
-  if (table === null) {
-    return false;
-  }
-  const assignment = table.assignments.get(payload.partitionId);
-  if (assignment === void 0) {
-    return false;
-  }
-  if (payload.primaryTerm !== assignment.primaryTerm) {
-    return false;
-  }
-  const isAssigned = assignment.primary === payload.nodeId || assignment.replicas.includes(payload.nodeId);
-  if (!isAssigned) {
-    return false;
-  }
-  if (assignment.state === "ACTIVE") {
-    if (assignment.inSyncSet.includes(payload.nodeId)) {
-      return true;
-    }
-    const updatedInSyncSet2 = [...assignment.inSyncSet, payload.nodeId];
-    const updatedAssignment2 = {
-      ...assignment,
-      inSyncSet: updatedInSyncSet2
-    };
-    const updatedAssignments2 = new Map(table.assignments);
-    updatedAssignments2.set(payload.partitionId, updatedAssignment2);
-    const updatedTable2 = {
-      ...table,
-      version: table.version + 1,
-      assignments: updatedAssignments2
-    };
-    return coordinator.putAllocation(payload.indexName, updatedTable2, table.version);
-  }
-  if (assignment.state !== "INITIALISING") {
-    return false;
-  }
-  const baseInSyncSet = assignment.inSyncSet.includes(payload.nodeId) ? assignment.inSyncSet : [...assignment.inSyncSet, payload.nodeId];
-  const updatedInSyncSet = ensurePrimaryInSyncSet(assignment, baseInSyncSet);
-  const updatedAssignment = {
-    ...assignment,
-    state: "ACTIVE",
-    inSyncSet: updatedInSyncSet
-  };
-  const updatedAssignments = new Map(table.assignments);
-  updatedAssignments.set(payload.partitionId, updatedAssignment);
-  const updatedTable = {
-    ...table,
-    version: table.version + 1,
-    assignments: updatedAssignments
-  };
-  return coordinator.putAllocation(payload.indexName, updatedTable, table.version);
-}
 
-// src/distribution/cluster/controller/event-loop.ts
-function createEventLoopState(initialIndexNames) {
-  return {
-    unwatchNodes: null,
-    unwatchSchemas: null,
-    unwatchTransport: null,
-    knownIndexes: new Set(initialIndexNames),
-    debounceTimer: null,
-    insyncQueue: Promise.resolve()
-  };
-}
-function clearEventLoopWatchers(state) {
-  if (state.unwatchNodes !== null) {
-    state.unwatchNodes();
-    state.unwatchNodes = null;
-  }
-  if (state.unwatchSchemas !== null) {
-    state.unwatchSchemas();
-    state.unwatchSchemas = null;
-  }
-  if (state.unwatchTransport !== null) {
-    state.unwatchTransport();
-    state.unwatchTransport = null;
-  }
-  if (state.debounceTimer !== null) {
-    clearTimeout(state.debounceTimer);
-    state.debounceTimer = null;
-  }
-}
-function isRecord2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isValidInteger2(value) {
-  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
-}
-function validateInsyncRemovePayload(decoded) {
-  if (!isRecord2(decoded)) {
-    return null;
-  }
-  if (typeof decoded.indexName !== "string") {
-    return null;
-  }
-  if (!isValidInteger2(decoded.partitionId)) {
-    return null;
-  }
-  if (typeof decoded.replicaNodeId !== "string") {
-    return null;
-  }
-  if (!isValidInteger2(decoded.primaryTerm)) {
-    return null;
-  }
-  return {
-    indexName: decoded.indexName,
-    partitionId: decoded.partitionId,
-    replicaNodeId: decoded.replicaNodeId,
-    primaryTerm: decoded.primaryTerm
-  };
-}
-async function runAllocatorForIndex(coordinator, indexName, nodes, isActive) {
+// src/distribution/cluster/controller/event-loop/allocation.ts
+var ALLOCATION_CAS_ATTEMPTS = 5;
+var ALLOCATION_RETRY_DELAY_MS = 1e3;
+var TEARDOWN_CAS_ATTEMPTS = 5;
+var TEARDOWN_RETRY_ROUNDS = 3;
+var TEARDOWN_RETRY_DELAY_MS = 500;
+async function runAllocatorForIndex(coordinator, indexName, nodes, isActive, attempt = 0) {
   if (!isActive()) {
     return;
   }
@@ -832,9 +590,20 @@ async function runAllocatorForIndex(coordinator, indexName, nodes, isActive) {
   if (!isActive()) {
     return;
   }
-  await coordinator.putAllocation(indexName, result.table, currentTable.version);
+  if (await coordinator.putAllocation(indexName, result.table, currentTable.version)) {
+    return;
+  }
+  if (attempt + 1 < ALLOCATION_CAS_ATTEMPTS) {
+    await runAllocatorForIndex(coordinator, indexName, nodes, isActive, attempt + 1);
+    return;
+  }
+  throw new NarsilError(
+    ErrorCodes.ALLOCATION_FAILED,
+    `Allocation for index '${indexName}' lost ${ALLOCATION_CAS_ATTEMPTS} compare-and-set attempts`,
+    { indexName, attempts: ALLOCATION_CAS_ATTEMPTS }
+  );
 }
-async function runAllocatorForAllIndexes(coordinator, knownIndexes, isActive, onError) {
+async function runAllocatorForAllIndexes(state, coordinator, isActive, onError) {
   if (!isActive()) {
     return;
   }
@@ -842,18 +611,23 @@ async function runAllocatorForAllIndexes(coordinator, knownIndexes, isActive, on
   if (nodes.length === 0 || !isActive()) {
     return;
   }
-  for (const indexName of knownIndexes) {
+  let anyIndexFailed = false;
+  for (const indexName of state.knownIndexes) {
     if (!isActive()) {
       return;
     }
     try {
       await runAllocatorForIndex(coordinator, indexName, nodes, isActive);
     } catch (error) {
+      anyIndexFailed = true;
       if (onError !== void 0) {
         onError(indexName, error);
       }
     }
   }
+  if (anyIndexFailed && isActive()) {
+    scheduleDebouncedAllocation(state, coordinator, isActive, onError, ALLOCATION_RETRY_DELAY_MS);
+  }
 }
 function scheduleDebouncedAllocation(state, coordinator, isActive, onError, debounceMs = 500) {
   if (state.debounceTimer !== null) {
@@ -861,9 +635,13 @@ function scheduleDebouncedAllocation(state, coordinator, isActive, onError, debo
   }
   state.debounceTimer = setTimeout(() => {
     state.debounceTimer = null;
-    runAllocatorForAllIndexes(coordinator, state.knownIndexes, isActive, onError).catch(() => {
+    runAllocatorForAllIndexes(state, coordinator, isActive, onError).catch(() => {
+      if (isActive()) {
+        scheduleDebouncedAllocation(state, coordinator, isActive, onError, ALLOCATION_RETRY_DELAY_MS);
+      }
     });
   }, debounceMs);
+  state.debounceTimer.unref?.();
 }
 async function handleSchemaCreated(indexName, coordinator, knownIndexes, isActive) {
   knownIndexes.add(indexName);
@@ -895,11 +673,28 @@ async function handleSchemaCreated(indexName, coordinator, knownIndexes, isActiv
     return;
   }
   const expectedVersion = storedTable !== null ? storedTable.version : null;
-  await coordinator.putAllocation(indexName, result.table, expectedVersion);
+  if (await coordinator.putAllocation(indexName, result.table, expectedVersion)) {
+    return;
+  }
+  await runAllocatorForIndex(coordinator, indexName, nodes, isActive);
 }
-var TEARDOWN_CAS_ATTEMPTS = 5;
-async function handleSchemaDropped(indexName, coordinator, knownIndexes, isActive) {
-  knownIndexes.delete(indexName);
+function scheduleTeardownRetry(indexName, coordinator, state, isActive, round, onError) {
+  const existing = state.teardownTimers.get(indexName);
+  if (existing !== void 0) {
+    clearTimeout(existing);
+  }
+  const timer = setTimeout(() => {
+    state.teardownTimers.delete(indexName);
+    tearDownAllocation(indexName, coordinator, state, isActive, round, onError).catch((error) => {
+      if (onError !== void 0) {
+        onError(indexName, error);
+      }
+    });
+  }, TEARDOWN_RETRY_DELAY_MS);
+  timer.unref?.();
+  state.teardownTimers.set(indexName, timer);
+}
+async function tearDownAllocation(indexName, coordinator, state, isActive, round, onError) {
   for (let attempt = 0; attempt < TEARDOWN_CAS_ATTEMPTS; attempt++) {
     if (!isActive()) {
       return;
@@ -929,461 +724,892 @@ async function handleSchemaDropped(indexName, coordinator, knownIndexes, isActiv
     await coordinator.deleteAllocation(indexName);
     return;
   }
-}
-async function handleSchemaEvent(event, coordinator, knownIndexes, isActive) {
-  if (event.type === "schema_created") {
-    await handleSchemaCreated(event.indexName, coordinator, knownIndexes, isActive);
-  } else if (event.type === "schema_dropped") {
-    await handleSchemaDropped(event.indexName, coordinator, knownIndexes, isActive);
+  if (round + 1 < TEARDOWN_RETRY_ROUNDS && isActive()) {
+    scheduleTeardownRetry(indexName, coordinator, state, isActive, round + 1, onError);
+    return;
   }
+  throw new NarsilError(
+    ErrorCodes.ALLOCATION_FAILED,
+    `Teardown of the allocation for dropped index '${indexName}' lost every compare-and-set attempt`,
+    { indexName, attempts: TEARDOWN_CAS_ATTEMPTS * TEARDOWN_RETRY_ROUNDS }
+  );
 }
-async function startEventLoop(state, coordinator, transport, nodeId, isActive, onError) {
-  clearEventLoopWatchers(state);
-  const unwatchNodes = await coordinator.watchNodes((_event) => {
-    scheduleDebouncedAllocation(state, coordinator, isActive, onError);
-  });
-  state.unwatchNodes = unwatchNodes;
-  const unwatchSchemas = await coordinator.watchSchemas((event) => {
-    handleSchemaEvent(event, coordinator, state.knownIndexes, isActive).catch(() => {
-    });
-  });
-  state.unwatchSchemas = unwatchSchemas;
-  const unwatchTransport = await transport.listen((message, respond) => {
-    if (!isActive()) {
-      return;
-    }
-    if (message.type === ReplicationMessageTypes.INSYNC_REMOVE) {
-      handleInsyncRemoveMessage(state, message, respond, coordinator, nodeId);
-    } else if (message.type === ClusterMessageTypes.BOOTSTRAP_COMPLETE) {
-      handleBootstrapCompleteMessage(message, respond, coordinator, nodeId);
-    }
-  });
-  state.unwatchTransport = unwatchTransport;
-  scheduleDebouncedAllocation(state, coordinator, isActive, onError);
-}
-function handleInsyncRemoveMessage(state, message, respond, coordinator, nodeId) {
-  let decoded;
-  try {
-    decoded = decode(message.payload);
-  } catch (_) {
+async function handleSchemaEvent(event, coordinator, state, isActive, onError) {
+  if (event.type === "schema_created") {
+    await handleSchemaCreated(event.indexName, coordinator, state.knownIndexes, isActive);
     return;
   }
-  const payload = validateInsyncRemovePayload(decoded);
-  if (payload === null) {
-    return;
+  if (event.type === "schema_dropped") {
+    state.knownIndexes.delete(event.indexName);
+    await tearDownAllocation(event.indexName, coordinator, state, isActive, 0, onError);
   }
-  state.insyncQueue = state.insyncQueue.then(async () => {
-    const table = await coordinator.getAllocation(payload.indexName);
+}
+
+// src/distribution/payload-guards.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isValidInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+}
+var INSYNC_CAS_ATTEMPTS = 5;
+var REFUSE = { outcome: "refuse" };
+var ACCEPT = { outcome: "accept" };
+async function updateInsyncSet(request, coordinator, decide) {
+  const refused = {
+    indexName: request.indexName,
+    partitionId: request.partitionId,
+    accepted: false
+  };
+  for (let attempt = 0; attempt < INSYNC_CAS_ATTEMPTS; attempt++) {
+    const table = await coordinator.getAllocation(request.indexName);
     if (table === null) {
-      return;
+      return refused;
     }
-    const assignment = table.assignments.get(payload.partitionId);
+    const assignment = table.assignments.get(request.partitionId);
     if (assignment === void 0) {
-      return;
+      return refused;
     }
-    if (assignment.primary !== message.sourceId) {
-      return;
+    if (request.primaryTerm !== assignment.primaryTerm) {
+      return refused;
     }
-    const confirmPayload = await handleInsyncRemoval(payload, coordinator);
-    const response = createInsyncConfirmMessage(confirmPayload, nodeId, message.requestId);
-    await respond(response);
-  }).catch(() => {
-  });
-}
-
-// src/distribution/cluster/controller/index.ts
-function createController(config) {
-  const { nodeId, coordinator, transport, leaseTtlMs, standbyRetryMs, knownIndexNames, onError } = config;
-  let electionState = createElectionState();
-  let eventLoopState = createEventLoopState(knownIndexNames);
-  let stopped = false;
-  function isActive() {
-    return electionState.active;
-  }
-  function stepDown() {
-    if (!electionState.active) {
-      return;
+    const decision = decide(assignment);
+    if (decision.outcome === "refuse") {
+      return refused;
     }
-    electionState.active = false;
-    clearElectionTimers(electionState);
-    clearEventLoopWatchers(eventLoopState);
-    if (!stopped) {
-      scheduleStandbyRetry(electionState, standbyRetryMs, () => {
-        tryElection().catch(() => {
-        });
-      });
+    if (decision.outcome === "accept") {
+      return { ...refused, accepted: true };
+    }
+    const updatedAssignments = new Map(table.assignments);
+    updatedAssignments.set(request.partitionId, decision.assignment);
+    const written = await coordinator.putAllocation(
+      request.indexName,
+      { ...table, version: table.version + 1, assignments: updatedAssignments },
+      table.version
+    );
+    if (written) {
+      return { ...refused, accepted: true };
     }
   }
-  async function becomeActive() {
-    if (electionState.active) {
-      return;
+  return refused;
+}
+async function requestInsyncRemoval(indexName, partitionId, replicaNodeId, primaryTerm, controllerNodeId, transport, sourceNodeId) {
+  const payload = {
+    indexName,
+    partitionId,
+    replicaNodeId,
+    primaryTerm
+  };
+  const message = createInsyncRemoveMessage(payload, sourceNodeId);
+  const response = await transport.send(controllerNodeId, message);
+  const confirmPayload = validateInsyncConfirmPayload(decode(response.payload));
+  return { accepted: confirmPayload.accepted };
+}
+function handleInsyncRemoval(payload, coordinator) {
+  return updateInsyncSet(payload, coordinator, (assignment) => {
+    if (!assignment.inSyncSet.includes(payload.replicaNodeId)) {
+      return ACCEPT;
     }
-    electionState.active = true;
-    startRenewalInterval(electionState, coordinator, nodeId, leaseTtlMs, stepDown);
-    try {
-      for (const indexName of await coordinator.listSchemas()) {
-        eventLoopState.knownIndexes.add(indexName);
+    return {
+      outcome: "write",
+      assignment: {
+        ...assignment,
+        inSyncSet: assignment.inSyncSet.filter((nodeId) => nodeId !== payload.replicaNodeId)
       }
-    } catch (_) {
+    };
+  });
+}
+async function requestInsyncAdmission(payload, controllerNodeId, transport, sourceNodeId) {
+  const message = createInsyncAddMessage(payload, sourceNodeId);
+  const response = await transport.send(controllerNodeId, message);
+  const confirmPayload = validateInsyncConfirmPayload(decode(response.payload));
+  return { accepted: confirmPayload.accepted };
+}
+function handleInsyncAdmission(payload, coordinator) {
+  return updateInsyncSet(payload, coordinator, (assignment) => {
+    if (assignment.state !== "ACTIVE") {
+      return REFUSE;
     }
-    await startEventLoop(eventLoopState, coordinator, transport, nodeId, isActive, onError);
-  }
-  async function tryElection() {
-    if (stopped) {
-      return;
+    if (!assignment.replicas.includes(payload.replicaNodeId)) {
+      return REFUSE;
     }
-    const acquired = await tryAcquireLease(coordinator, nodeId, leaseTtlMs);
-    if (acquired) {
-      await becomeActive();
-    } else {
-      scheduleStandbyRetry(electionState, standbyRetryMs, () => {
-        tryElection().catch(() => {
-        });
-      });
+    if (payload.appliedSeqNo < assignment.commitPoint || payload.appliedSeqNo < payload.commitPoint) {
+      return REFUSE;
     }
-  }
-  const controller = {
-    get isActive() {
-      return electionState.active;
-    },
-    async start() {
-      stopped = false;
-      await tryElection();
-    },
-    async stop() {
-      stopped = true;
-      clearElectionTimers(electionState);
-      clearEventLoopWatchers(eventLoopState);
-      if (electionState.active) {
-        electionState.active = false;
-        try {
-          await releaseLease(coordinator);
-        } catch (_) {
-        }
-      }
-    },
-    async shutdown() {
-      await controller.stop();
-      eventLoopState = createEventLoopState([]);
-      electionState = createElectionState();
+    const alreadyInSync = assignment.inSyncSet.includes(payload.replicaNodeId);
+    const commitPoint = Math.max(assignment.commitPoint, payload.commitPoint);
+    if (alreadyInSync && commitPoint === assignment.commitPoint) {
+      return ACCEPT;
     }
-  };
-  return controller;
-}
-function computeBackoffMs(baseMs, maxMs, retryCount) {
-  const exponential = baseMs * 2 ** retryCount;
-  const capped = Math.min(exponential, maxMs);
-  const jitter = capped * (0.5 + Math.random() * 0.5);
-  return Math.floor(jitter);
+    return {
+      outcome: "write",
+      assignment: {
+        ...assignment,
+        inSyncSet: alreadyInSync ? assignment.inSyncSet : [...assignment.inSyncSet, payload.replicaNodeId],
+        commitPoint
+      }
+    };
+  });
 }
-async function resolvePrimaryTerm(indexName, partitionId, coordinator) {
-  const table = await coordinator.getAllocation(indexName);
-  if (table === null) {
+function validateBootstrapCompletePayload(decoded) {
+  if (!isRecord(decoded)) {
     return null;
   }
-  const assignment = table.assignments.get(partitionId);
-  if (assignment === void 0) {
+  if (typeof decoded.indexName !== "string" || decoded.indexName.length === 0) {
     return null;
   }
-  return assignment.primaryTerm;
-}
-async function resolveControllerTargets(coordinator, controllerNodeId) {
-  const targets = [controllerNodeId];
-  try {
-    const nodes = await coordinator.listNodes();
-    const registration = nodes.find((entry) => entry.nodeId === controllerNodeId);
-    if (registration !== void 0 && registration.address.length > 0 && registration.address !== controllerNodeId) {
-      targets.push(registration.address);
-    }
-  } catch (_) {
-    return targets;
+  if (!isValidInteger(decoded.partitionId) || decoded.partitionId < 0) {
+    return null;
   }
-  return targets;
-}
-async function reportBootstrapComplete(indexName, partitionId, nodeId, coordinator, transport) {
-  const controllerNodeId = await coordinator.getLeaseHolder(CONTROLLER_LEASE_KEY);
-  if (controllerNodeId === null) {
-    return false;
+  if (typeof decoded.nodeId !== "string") {
+    return null;
   }
-  const primaryTerm = await resolvePrimaryTerm(indexName, partitionId, coordinator);
-  if (primaryTerm === null) {
-    return false;
+  if (!isValidInteger(decoded.primaryTerm)) {
+    return null;
   }
-  const payload = {
+  return {
+    indexName: decoded.indexName,
+    partitionId: decoded.partitionId,
+    nodeId: decoded.nodeId,
+    primaryTerm: decoded.primaryTerm
+  };
+}
+async function sendRejection(respond, controllerNodeId, requestId, indexName, partitionId) {
+  const resultPayload = {
     indexName,
     partitionId,
-    nodeId,
-    primaryTerm
+    accepted: false
   };
-  const message = {
+  const response = {
     type: ClusterMessageTypes.BOOTSTRAP_COMPLETE,
-    sourceId: nodeId,
-    requestId: generateId(),
-    payload: encode(payload)
+    sourceId: controllerNodeId,
+    requestId,
+    payload: encode(resultPayload)
   };
-  for (const target of await resolveControllerTargets(coordinator, controllerNodeId)) {
-    try {
-      const response = await transport.send(target, message);
-      return isAcceptedResponse(response);
-    } catch (_) {
-    }
+  await respond(response);
+}
+async function rejectBootstrapComplete(message, respond, controllerNodeId) {
+  let decoded;
+  try {
+    decoded = decode(message.payload);
+  } catch (_) {
+    await sendRejection(respond, controllerNodeId, message.requestId, "", -1);
+    return;
   }
-  return false;
+  const payload = validateBootstrapCompletePayload(decoded);
+  if (payload === null) {
+    await sendRejection(respond, controllerNodeId, message.requestId, "", -1);
+    return;
+  }
+  await sendRejection(respond, controllerNodeId, message.requestId, payload.indexName, payload.partitionId);
 }
-function isAcceptedResponse(response) {
+async function handleBootstrapCompleteMessage(message, respond, coordinator, controllerNodeId) {
+  let decoded;
   try {
-    const decoded = decode(response.payload);
-    if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) {
-      return false;
-    }
-    return decoded.accepted === true;
+    decoded = decode(message.payload);
   } catch (_) {
-    return false;
+    await sendRejection(respond, controllerNodeId, message.requestId, "", -1);
+    return;
+  }
+  const payload = validateBootstrapCompletePayload(decoded);
+  if (payload === null) {
+    await sendRejection(respond, controllerNodeId, message.requestId, "", -1);
+    return;
+  }
+  if (message.sourceId !== payload.nodeId) {
+    await sendRejection(respond, controllerNodeId, message.requestId, payload.indexName, payload.partitionId);
+    return;
+  }
+  let accepted;
+  try {
+    accepted = await processBootstrapComplete(payload, coordinator);
+  } catch (_) {
+    await sendRejection(respond, controllerNodeId, message.requestId, payload.indexName, payload.partitionId);
+    return;
   }
+  const resultPayload = {
+    indexName: payload.indexName,
+    partitionId: payload.partitionId,
+    accepted
+  };
+  await respond({
+    type: ClusterMessageTypes.BOOTSTRAP_COMPLETE,
+    sourceId: controllerNodeId,
+    requestId: message.requestId,
+    payload: encode(resultPayload)
+  });
 }
-async function bootstrapPartition(state, coordinator, transport, nodeId, bootstrapRetryBaseMs, bootstrapRetryMaxMs, bootstrapMaxRetries, onBootstrapPartition, onError) {
-  for (let attempt = 0; attempt <= bootstrapMaxRetries; attempt++) {
-    if (state.aborted) {
+var BOOTSTRAP_CAS_ATTEMPTS = 5;
+function ensurePrimaryInSyncSet(assignment, inSyncSet) {
+  if (assignment.primary === null) {
+    return inSyncSet;
+  }
+  if (inSyncSet.includes(assignment.primary)) {
+    return inSyncSet;
+  }
+  return [assignment.primary, ...inSyncSet];
+}
+async function processBootstrapComplete(payload, coordinator) {
+  for (let attempt = 0; attempt < BOOTSTRAP_CAS_ATTEMPTS; attempt++) {
+    const table = await coordinator.getAllocation(payload.indexName);
+    if (table === null) {
       return false;
     }
-    const synced = await runBootstrapSyncAttempt(state, onBootstrapPartition, onError);
-    if (state.aborted) {
+    const assignment = table.assignments.get(payload.partitionId);
+    if (assignment === void 0) {
       return false;
     }
-    if (synced) {
-      return retryReportBootstrapComplete(
-        state,
-        coordinator,
-        transport,
-        nodeId,
-        bootstrapRetryBaseMs,
-        bootstrapRetryMaxMs,
-        bootstrapMaxRetries,
-        onError
-      );
-    }
-    if (attempt < bootstrapMaxRetries) {
-      const backoffMs = computeBackoffMs(bootstrapRetryBaseMs, bootstrapRetryMaxMs, attempt);
-      await waitWithAbort(state, backoffMs);
-    }
-  }
-  return false;
-}
-async function runBootstrapSyncAttempt(state, onBootstrapPartition, onError) {
-  try {
-    return await onBootstrapPartition(state.indexName, state.partitionId, state.primaryNodeId);
-  } catch (error) {
-    if (state.aborted) {
+    if (payload.primaryTerm !== assignment.primaryTerm) {
       return false;
     }
-    if (onError !== void 0) {
-      const cause = error instanceof Error ? error.message : String(error);
-      onError(
-        new NarsilError(
-          ErrorCodes.NODE_BOOTSTRAP_FAILED,
-          `Bootstrap sync failed for ${state.indexName}:${state.partitionId}`,
-          { indexName: state.indexName, partitionId: state.partitionId, cause }
-        )
-      );
+    if (assignment.primary !== payload.nodeId && !assignment.replicas.includes(payload.nodeId)) {
+      return false;
     }
-    return false;
-  }
-}
-async function retryReportBootstrapComplete(state, coordinator, transport, nodeId, bootstrapRetryBaseMs, bootstrapRetryMaxMs, bootstrapMaxRetries, onError) {
-  for (let attempt = 0; attempt <= bootstrapMaxRetries; attempt++) {
-    if (state.aborted) {
+    if (assignment.state !== "INITIALISING") {
       return false;
     }
-    const accepted = await reportBootstrapComplete(state.indexName, state.partitionId, nodeId, coordinator, transport);
-    if (accepted) {
+    const baseInSyncSet = assignment.inSyncSet.includes(payload.nodeId) ? assignment.inSyncSet : [...assignment.inSyncSet, payload.nodeId];
+    const updatedAssignments = new Map(table.assignments);
+    updatedAssignments.set(payload.partitionId, {
+      ...assignment,
+      state: "ACTIVE",
+      inSyncSet: ensurePrimaryInSyncSet(assignment, baseInSyncSet)
+    });
+    const written = await coordinator.putAllocation(
+      payload.indexName,
+      { ...table, version: table.version + 1, assignments: updatedAssignments },
+      table.version
+    );
+    if (written) {
       return true;
     }
-    if (attempt < bootstrapMaxRetries && !state.aborted) {
-      const backoffMs = computeBackoffMs(bootstrapRetryBaseMs, bootstrapRetryMaxMs, attempt);
-      await waitWithAbort(state, backoffMs);
-    }
-  }
-  if (onError !== void 0) {
-    onError(
-      new NarsilError(
-        ErrorCodes.NODE_BOOTSTRAP_FAILED,
-        `Failed to report bootstrap completion for ${state.indexName}:${state.partitionId} after ${bootstrapMaxRetries + 1} attempts`,
-        { indexName: state.indexName, partitionId: state.partitionId }
-      )
-    );
   }
   return false;
 }
-function waitWithAbort(state, ms) {
-  return new Promise((resolve) => {
-    if (state.aborted) {
-      resolve();
-      return;
-    }
-    state.abortResolve = resolve;
-    state.retryTimer = setTimeout(() => {
-      state.retryTimer = null;
-      state.abortResolve = null;
-      resolve();
-    }, ms);
-  });
-}
-function abortBootstrapState(state) {
-  state.aborted = true;
-  if (state.retryTimer !== null) {
-    clearTimeout(state.retryTimer);
-    state.retryTimer = null;
+
+// src/distribution/cluster/controller/event-loop/insync-messages.ts
+var UNKNOWN_PARTITION_ID = -1;
+function validateInsyncRemovePayload(decoded) {
+  if (!isRecord(decoded)) {
+    return null;
   }
-  if (state.abortResolve !== null) {
-    state.abortResolve();
-    state.abortResolve = null;
+  if (typeof decoded.indexName !== "string") {
+    return null;
+  }
+  if (!isValidInteger(decoded.partitionId)) {
+    return null;
+  }
+  if (typeof decoded.replicaNodeId !== "string") {
+    return null;
+  }
+  if (!isValidInteger(decoded.primaryTerm)) {
+    return null;
   }
-}
-function createBootstrapState(indexName, partitionId, primaryNodeId) {
   return {
-    indexName,
-    partitionId,
-    primaryNodeId,
-    retryCount: 0,
-    retryTimer: null,
-    aborted: false,
-    abortResolve: null
+    indexName: decoded.indexName,
+    partitionId: decoded.partitionId,
+    replicaNodeId: decoded.replicaNodeId,
+    primaryTerm: decoded.primaryTerm
   };
 }
-
-// src/distribution/cluster/node-lifecycle/allocation-watcher.ts
-function partitionKey(indexName, partitionId) {
-  return `${indexName}:${partitionId}`;
+function validateInsyncAddPayload(decoded) {
+  const base = validateInsyncRemovePayload(decoded);
+  if (base === null || !isRecord(decoded)) {
+    return null;
+  }
+  if (!isValidInteger(decoded.appliedSeqNo) || decoded.appliedSeqNo < 0) {
+    return null;
+  }
+  if (!isValidInteger(decoded.commitPoint) || decoded.commitPoint < 0) {
+    return null;
+  }
+  return { ...base, appliedSeqNo: decoded.appliedSeqNo, commitPoint: decoded.commitPoint };
 }
-function createAllocationWatcherState() {
+function decodeMessage(message) {
+  try {
+    return decode(message.payload);
+  } catch (_) {
+    return null;
+  }
+}
+function describeRequest(decoded) {
+  if (!isRecord(decoded)) {
+    return { indexName: "", partitionId: UNKNOWN_PARTITION_ID };
+  }
   return {
-    unwatchAllocation: null,
-    debounceTimer: null,
-    activeBootstraps: /* @__PURE__ */ new Map(),
-    trackedPartitions: /* @__PURE__ */ new Map(),
-    pendingTables: /* @__PURE__ */ new Map(),
-    stopped: false
+    indexName: typeof decoded.indexName === "string" ? decoded.indexName : "",
+    partitionId: isValidInteger(decoded.partitionId) ? decoded.partitionId : UNKNOWN_PARTITION_ID
   };
 }
-async function startAllocationWatcher(state, config) {
-  const unwatchAllocation = await config.coordinator.watchAllocation((event) => {
-    if (state.stopped) {
-      return;
-    }
-    scheduleProcessAllocation(state, config, event.table);
+async function assertSenderLeadsPartition(coordinator, indexName, partitionId, sourceId) {
+  const table = await coordinator.getAllocation(indexName);
+  const assignment = table?.assignments.get(partitionId);
+  if (assignment === void 0) {
+    return false;
+  }
+  return assignment.primary === sourceId;
+}
+function enqueue(state, task) {
+  state.insyncQueue = state.insyncQueue.then(task).catch(() => {
   });
-  state.unwatchAllocation = unwatchAllocation;
 }
-function scheduleProcessAllocation(state, config, table) {
-  state.pendingTables.set(table.indexName, table);
-  if (state.debounceTimer !== null) {
-    clearTimeout(state.debounceTimer);
+async function respondRefusal(respond, request, nodeId, requestId) {
+  const payload = {
+    indexName: request.indexName,
+    partitionId: request.partitionId,
+    accepted: false
+  };
+  try {
+    await respond(createInsyncConfirmMessage(payload, nodeId, requestId));
+  } catch (_) {
   }
-  state.debounceTimer = setTimeout(() => {
-    state.debounceTimer = null;
-    const tablesToProcess = Array.from(state.pendingTables.values());
-    state.pendingTables.clear();
-    for (const pending of tablesToProcess) {
-      processAllocationChange(state, config, pending);
-    }
-  }, config.allocationDebounceMs);
 }
-function processAllocationChange(state, config, table) {
-  if (state.stopped) {
+function handleInsyncRemoveMessage(state, message, respond, coordinator, nodeId, isActive) {
+  const decoded = decodeMessage(message);
+  const payload = validateInsyncRemovePayload(decoded);
+  if (payload === null) {
+    void respondRefusal(respond, describeRequest(decoded), nodeId, message.requestId);
     return;
   }
-  const nodeId = config.registration.nodeId;
-  const currentKeys = /* @__PURE__ */ new Set();
-  for (const [partitionId, assignment] of table.assignments) {
-    if (!isNodeAssigned(assignment, nodeId)) {
-      continue;
-    }
-    const key = partitionKey(table.indexName, partitionId);
-    currentKeys.add(key);
-    const existing = state.trackedPartitions.get(key);
-    const isPrimary = assignment.primary === nodeId;
-    if (existing === void 0) {
-      handleNewAssignment(state, config, table.indexName, partitionId, assignment, nodeId);
-    } else {
-      handleExistingAssignment(state, config, existing, assignment, nodeId);
+  enqueue(state, async () => {
+    const leadsPartition = await assertSenderLeadsPartition(
+      coordinator,
+      payload.indexName,
+      payload.partitionId,
+      message.sourceId
+    );
+    if (!leadsPartition || !isActive()) {
+      await respondRefusal(respond, payload, nodeId, message.requestId);
+      return;
     }
-    state.trackedPartitions.set(key, {
-      indexName: table.indexName,
-      partitionId,
-      isPrimary,
-      primaryNodeId: assignment.primary,
-      primaryTerm: assignment.primaryTerm
-    });
-  }
-  removeUnassignedPartitions(state, config, table.indexName, currentKeys);
-}
-function isNodeAssigned(assignment, nodeId) {
-  if (assignment.primary === nodeId) {
-    return true;
-  }
-  return assignment.replicas.includes(nodeId);
+    const confirmPayload = await handleInsyncRemoval(payload, coordinator);
+    await respond(createInsyncConfirmMessage(confirmPayload, nodeId, message.requestId));
+  });
 }
-function handleNewAssignment(state, config, indexName, partitionId, assignment, nodeId) {
-  if (assignment.state === "ACTIVE" && assignment.primary === nodeId) {
-    return;
-  }
-  if (assignment.primary === null) {
+function handleInsyncAddMessage(state, message, respond, coordinator, nodeId, isActive) {
+  const decoded = decodeMessage(message);
+  const payload = validateInsyncAddPayload(decoded);
+  if (payload === null) {
+    void respondRefusal(respond, describeRequest(decoded), nodeId, message.requestId);
     return;
   }
-  if (assignment.primary === nodeId) {
-    if (assignment.state === "INITIALISING") {
-      startBootstrap(state, config, indexName, partitionId, nodeId);
+  enqueue(state, async () => {
+    const leadsPartition = await assertSenderLeadsPartition(
+      coordinator,
+      payload.indexName,
+      payload.partitionId,
+      message.sourceId
+    );
+    if (!leadsPartition || !isActive()) {
+      await respondRefusal(respond, payload, nodeId, message.requestId);
+      return;
     }
-    return;
-  }
-  startBootstrap(state, config, indexName, partitionId, assignment.primary);
+    const confirmPayload = await handleInsyncAdmission(payload, coordinator);
+    await respond(createInsyncConfirmMessage(confirmPayload, nodeId, message.requestId));
+  });
 }
-function handleExistingAssignment(state, config, existing, assignment, nodeId) {
-  if (existing.isPrimary && assignment.primary !== nodeId && assignment.primaryTerm > existing.primaryTerm) {
-    if (assignment.primary !== null) {
-      if (config.onPrimaryDemotion !== void 0) {
-        config.onPrimaryDemotion(existing.indexName, existing.partitionId, assignment.primary);
-      }
-      startBootstrap(state, config, existing.indexName, existing.partitionId, assignment.primary);
+function handleQueuedBootstrapComplete(state, message, respond, coordinator, nodeId, isActive) {
+  enqueue(state, () => {
+    if (!isActive()) {
+      return rejectBootstrapComplete(message, respond, nodeId);
     }
-    return;
+    return handleBootstrapCompleteMessage(message, respond, coordinator, nodeId);
+  });
+}
+
+// src/distribution/cluster/controller/event-loop/state.ts
+function createEventLoopState(initialIndexNames) {
+  return {
+    unwatchNodes: null,
+    unwatchSchemas: null,
+    unwatchTransport: null,
+    knownIndexes: new Set(initialIndexNames),
+    debounceTimer: null,
+    teardownTimers: /* @__PURE__ */ new Map(),
+    insyncQueue: Promise.resolve()
+  };
+}
+function clearEventLoopWatchers(state) {
+  if (state.unwatchNodes !== null) {
+    state.unwatchNodes();
+    state.unwatchNodes = null;
   }
-  if (assignment.primary !== null && replicaNeedsResync(state, existing, assignment, nodeId)) {
-    startBootstrap(state, config, existing.indexName, existing.partitionId, assignment.primary);
+  if (state.unwatchSchemas !== null) {
+    state.unwatchSchemas();
+    state.unwatchSchemas = null;
   }
-}
-function replicaNeedsResync(state, existing, assignment, nodeId) {
-  if (assignment.state !== "ACTIVE") {
-    return false;
+  if (state.unwatchTransport !== null) {
+    state.unwatchTransport();
+    state.unwatchTransport = null;
   }
-  if (assignment.primary === null || assignment.primary === nodeId) {
-    return false;
+  if (state.debounceTimer !== null) {
+    clearTimeout(state.debounceTimer);
+    state.debounceTimer = null;
   }
-  if (!assignment.replicas.includes(nodeId)) {
-    return false;
+  for (const timer of state.teardownTimers.values()) {
+    clearTimeout(timer);
   }
-  if (assignment.inSyncSet.includes(nodeId)) {
-    return false;
+  state.teardownTimers.clear();
+}
+
+// src/distribution/cluster/controller/event-loop/index.ts
+async function startEventLoop(state, coordinator, transport, nodeId, isActive, onError) {
+  clearEventLoopWatchers(state);
+  try {
+    state.unwatchNodes = await coordinator.watchNodes((_event) => {
+      scheduleDebouncedAllocation(state, coordinator, isActive, onError);
+    });
+    state.unwatchSchemas = await coordinator.watchSchemas((event) => {
+      handleSchemaEvent(event, coordinator, state, isActive, onError).catch((error) => {
+        if (onError !== void 0) {
+          onError(event.indexName, error);
+        }
+      });
+    });
+    state.unwatchTransport = await transport.listen((message, respond) => {
+      if (!isActive()) {
+        return;
+      }
+      if (message.type === ReplicationMessageTypes.INSYNC_REMOVE) {
+        handleInsyncRemoveMessage(state, message, respond, coordinator, nodeId, isActive);
+      } else if (message.type === ReplicationMessageTypes.INSYNC_ADD) {
+        handleInsyncAddMessage(state, message, respond, coordinator, nodeId, isActive);
+      } else if (message.type === ClusterMessageTypes.BOOTSTRAP_COMPLETE) {
+        handleQueuedBootstrapComplete(state, message, respond, coordinator, nodeId, isActive);
+      }
+    });
+  } catch (error) {
+    clearEventLoopWatchers(state);
+    throw error;
   }
-  return !state.activeBootstraps.has(partitionKey(existing.indexName, existing.partitionId));
+  scheduleDebouncedAllocation(state, coordinator, isActive, onError);
 }
-function startBootstrap(state, config, indexName, partitionId, primaryNodeId) {
-  const key = partitionKey(indexName, partitionId);
-  const existingBootstrap = state.activeBootstraps.get(key);
-  if (existingBootstrap !== void 0) {
-    abortBootstrapState(existingBootstrap);
+
+// src/distribution/cluster/controller/index.ts
+function createController(config) {
+  const { nodeId, coordinator, transport, leaseTtlMs, standbyRetryMs, knownIndexNames, onError } = config;
+  let electionState = createElectionState();
+  let eventLoopState = createEventLoopState(knownIndexNames);
+  let stopped = false;
+  function isActive() {
+    return electionState.active;
   }
-  const bootstrapState = createBootstrapState(indexName, partitionId, primaryNodeId);
-  state.activeBootstraps.set(key, bootstrapState);
-  bootstrapPartition(
-    bootstrapState,
-    config.coordinator,
-    config.transport,
-    config.registration.nodeId,
-    config.bootstrapRetryBaseMs,
-    config.bootstrapRetryMaxMs,
-    config.bootstrapMaxRetries,
-    config.onBootstrapPartition,
+  function stepDown() {
+    if (!electionState.active) {
+      return;
+    }
+    electionState.active = false;
+    clearElectionTimers(electionState);
+    clearEventLoopWatchers(eventLoopState);
+    if (!stopped) {
+      scheduleStandbyRetry(electionState, standbyRetryMs, () => {
+        tryElection().catch(() => {
+        });
+      });
+    }
+  }
+  async function becomeActive() {
+    if (electionState.active) {
+      return;
+    }
+    electionState.active = true;
+    startRenewalInterval(electionState, coordinator, nodeId, leaseTtlMs, stepDown);
+    try {
+      for (const indexName of await coordinator.listSchemas()) {
+        eventLoopState.knownIndexes.add(indexName);
+      }
+    } catch (_) {
+    }
+    try {
+      await startEventLoop(eventLoopState, coordinator, transport, nodeId, isActive, onError);
+    } catch (error) {
+      electionState.active = false;
+      clearElectionTimers(electionState);
+      try {
+        await releaseLease(coordinator);
+      } catch (_) {
+      }
+      throw error;
+    }
+  }
+  async function tryElection() {
+    if (stopped) {
+      return;
+    }
+    const acquired = await tryAcquireLease(coordinator, nodeId, leaseTtlMs);
+    if (acquired) {
+      await becomeActive();
+    } else {
+      scheduleStandbyRetry(electionState, standbyRetryMs, () => {
+        tryElection().catch(() => {
+        });
+      });
+    }
+  }
+  const controller = {
+    get isActive() {
+      return electionState.active;
+    },
+    async start() {
+      stopped = false;
+      await tryElection();
+    },
+    async stop() {
+      stopped = true;
+      clearElectionTimers(electionState);
+      clearEventLoopWatchers(eventLoopState);
+      if (electionState.active) {
+        electionState.active = false;
+        try {
+          await releaseLease(coordinator);
+        } catch (_) {
+        }
+      }
+    },
+    async shutdown() {
+      await controller.stop();
+      eventLoopState = createEventLoopState([]);
+      electionState = createElectionState();
+    }
+  };
+  return controller;
+}
+function computeBackoffMs(baseMs, maxMs, retryCount) {
+  const exponential = baseMs * 2 ** retryCount;
+  const capped = Math.min(exponential, maxMs);
+  const jitter = capped * (0.5 + Math.random() * 0.5);
+  return Math.floor(jitter);
+}
+async function resolvePrimaryTerm(indexName, partitionId, coordinator) {
+  const table = await coordinator.getAllocation(indexName);
+  if (table === null) {
+    return null;
+  }
+  const assignment = table.assignments.get(partitionId);
+  if (assignment === void 0) {
+    return null;
+  }
+  return assignment.primaryTerm;
+}
+async function resolveControllerTargets(coordinator, controllerNodeId) {
+  const targets = [controllerNodeId];
+  try {
+    const nodes = await coordinator.listNodes();
+    const registration = nodes.find((entry) => entry.nodeId === controllerNodeId);
+    if (registration !== void 0 && registration.address.length > 0 && registration.address !== controllerNodeId) {
+      targets.push(registration.address);
+    }
+  } catch (_) {
+    return targets;
+  }
+  return targets;
+}
+async function reportBootstrapComplete(indexName, partitionId, nodeId, coordinator, transport) {
+  const controllerNodeId = await coordinator.getLeaseHolder(CONTROLLER_LEASE_KEY);
+  if (controllerNodeId === null) {
+    return false;
+  }
+  const primaryTerm = await resolvePrimaryTerm(indexName, partitionId, coordinator);
+  if (primaryTerm === null) {
+    return false;
+  }
+  const payload = {
+    indexName,
+    partitionId,
+    nodeId,
+    primaryTerm
+  };
+  const message = {
+    type: ClusterMessageTypes.BOOTSTRAP_COMPLETE,
+    sourceId: nodeId,
+    requestId: generateId(),
+    payload: encode(payload)
+  };
+  for (const target of await resolveControllerTargets(coordinator, controllerNodeId)) {
+    try {
+      const response = await transport.send(target, message);
+      return isAcceptedResponse(response);
+    } catch (_) {
+    }
+  }
+  return false;
+}
+function isAcceptedResponse(response) {
+  try {
+    const decoded = decode(response.payload);
+    if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) {
+      return false;
+    }
+    return decoded.accepted === true;
+  } catch (_) {
+    return false;
+  }
+}
+async function partitionAwaitsBootstrapReport(state, coordinator) {
+  try {
+    const table = await coordinator.getAllocation(state.indexName);
+    const assignment = table?.assignments.get(state.partitionId);
+    if (assignment === void 0) {
+      return true;
+    }
+    return assignment.state === "INITIALISING";
+  } catch (_) {
+    return true;
+  }
+}
+async function bootstrapPartition(state, coordinator, transport, nodeId, bootstrapRetryBaseMs, bootstrapRetryMaxMs, bootstrapMaxRetries, onBootstrapPartition, onError) {
+  for (let attempt = 0; attempt <= bootstrapMaxRetries; attempt++) {
+    if (state.aborted) {
+      return false;
+    }
+    const synced = await runBootstrapSyncAttempt(state, onBootstrapPartition, onError);
+    if (state.aborted) {
+      return false;
+    }
+    if (synced) {
+      if (!await partitionAwaitsBootstrapReport(state, coordinator)) {
+        return true;
+      }
+      return retryReportBootstrapComplete(
+        state,
+        coordinator,
+        transport,
+        nodeId,
+        bootstrapRetryBaseMs,
+        bootstrapRetryMaxMs,
+        bootstrapMaxRetries,
+        onError
+      );
+    }
+    if (attempt < bootstrapMaxRetries) {
+      const backoffMs = computeBackoffMs(bootstrapRetryBaseMs, bootstrapRetryMaxMs, attempt);
+      await waitWithAbort(state, backoffMs);
+    }
+  }
+  return false;
+}
+async function runBootstrapSyncAttempt(state, onBootstrapPartition, onError) {
+  try {
+    return await onBootstrapPartition(state.indexName, state.partitionId, state.primaryNodeId);
+  } catch (error) {
+    if (state.aborted) {
+      return false;
+    }
+    if (onError !== void 0) {
+      const cause = error instanceof Error ? error.message : String(error);
+      onError(
+        new NarsilError(
+          ErrorCodes.NODE_BOOTSTRAP_FAILED,
+          `Bootstrap sync failed for ${state.indexName}:${state.partitionId}`,
+          { indexName: state.indexName, partitionId: state.partitionId, cause }
+        )
+      );
+    }
+    return false;
+  }
+}
+async function retryReportBootstrapComplete(state, coordinator, transport, nodeId, bootstrapRetryBaseMs, bootstrapRetryMaxMs, bootstrapMaxRetries, onError) {
+  for (let attempt = 0; attempt <= bootstrapMaxRetries; attempt++) {
+    if (state.aborted) {
+      return false;
+    }
+    if (attempt > 0 && !await partitionAwaitsBootstrapReport(state, coordinator)) {
+      return true;
+    }
+    const accepted = await reportBootstrapComplete(state.indexName, state.partitionId, nodeId, coordinator, transport);
+    if (accepted) {
+      return true;
+    }
+    if (!await partitionAwaitsBootstrapReport(state, coordinator)) {
+      return true;
+    }
+    if (attempt < bootstrapMaxRetries && !state.aborted) {
+      const backoffMs = computeBackoffMs(bootstrapRetryBaseMs, bootstrapRetryMaxMs, attempt);
+      await waitWithAbort(state, backoffMs);
+    }
+  }
+  if (onError !== void 0) {
+    onError(
+      new NarsilError(
+        ErrorCodes.NODE_BOOTSTRAP_FAILED,
+        `Failed to report bootstrap completion for ${state.indexName}:${state.partitionId} after ${bootstrapMaxRetries + 1} attempts`,
+        { indexName: state.indexName, partitionId: state.partitionId }
+      )
+    );
+  }
+  return false;
+}
+function waitWithAbort(state, ms) {
+  return new Promise((resolve) => {
+    if (state.aborted) {
+      resolve();
+      return;
+    }
+    state.abortResolve = resolve;
+    state.retryTimer = setTimeout(() => {
+      state.retryTimer = null;
+      state.abortResolve = null;
+      resolve();
+    }, ms);
+  });
+}
+function abortBootstrapState(state) {
+  state.aborted = true;
+  if (state.retryTimer !== null) {
+    clearTimeout(state.retryTimer);
+    state.retryTimer = null;
+  }
+  if (state.abortResolve !== null) {
+    state.abortResolve();
+    state.abortResolve = null;
+  }
+}
+function createBootstrapState(indexName, partitionId, primaryNodeId) {
+  return {
+    indexName,
+    partitionId,
+    primaryNodeId,
+    retryCount: 0,
+    retryTimer: null,
+    aborted: false,
+    abortResolve: null
+  };
+}
+
+// src/distribution/cluster/node-lifecycle/allocation-watcher.ts
+function partitionKey(indexName, partitionId) {
+  return `${indexName}:${partitionId}`;
+}
+function createAllocationWatcherState() {
+  return {
+    unwatchAllocation: null,
+    debounceTimer: null,
+    activeBootstraps: /* @__PURE__ */ new Map(),
+    trackedPartitions: /* @__PURE__ */ new Map(),
+    pendingTables: /* @__PURE__ */ new Map(),
+    restartWaiters: /* @__PURE__ */ new Map(),
+    stopped: false
+  };
+}
+async function startAllocationWatcher(state, config) {
+  const unwatchAllocation = await config.coordinator.watchAllocation((event) => {
+    if (state.stopped) {
+      return;
+    }
+    scheduleProcessAllocation(state, config, event.table);
+  });
+  state.unwatchAllocation = unwatchAllocation;
+}
+function scheduleProcessAllocation(state, config, table) {
+  state.pendingTables.set(table.indexName, table);
+  if (state.debounceTimer !== null) {
+    clearTimeout(state.debounceTimer);
+  }
+  state.debounceTimer = setTimeout(() => {
+    state.debounceTimer = null;
+    const tablesToProcess = Array.from(state.pendingTables.values());
+    state.pendingTables.clear();
+    for (const pending of tablesToProcess) {
+      processAllocationChange(state, config, pending);
+    }
+  }, config.allocationDebounceMs);
+}
+function processAllocationChange(state, config, table) {
+  if (state.stopped) {
+    return;
+  }
+  const nodeId = config.registration.nodeId;
+  const currentKeys = /* @__PURE__ */ new Set();
+  for (const [partitionId, assignment] of table.assignments) {
+    if (!isNodeAssigned(assignment, nodeId)) {
+      continue;
+    }
+    const key = partitionKey(table.indexName, partitionId);
+    currentKeys.add(key);
+    const existing = state.trackedPartitions.get(key);
+    const isPrimary = assignment.primary === nodeId;
+    if (existing === void 0) {
+      handleNewAssignment(state, config, table.indexName, partitionId, assignment, nodeId);
+    } else {
+      handleExistingAssignment(state, config, existing, assignment, nodeId);
+    }
+    state.trackedPartitions.set(key, {
+      indexName: table.indexName,
+      partitionId,
+      isPrimary,
+      primaryNodeId: assignment.primary,
+      primaryTerm: assignment.primaryTerm
+    });
+  }
+  removeUnassignedPartitions(state, config, table.indexName, currentKeys);
+}
+function isNodeAssigned(assignment, nodeId) {
+  if (assignment.primary === nodeId) {
+    return true;
+  }
+  return assignment.replicas.includes(nodeId);
+}
+function handleNewAssignment(state, config, indexName, partitionId, assignment, nodeId) {
+  if (assignment.state === "ACTIVE" && assignment.primary === nodeId) {
+    return;
+  }
+  if (assignment.primary === null) {
+    return;
+  }
+  if (assignment.primary === nodeId) {
+    if (assignment.state === "INITIALISING") {
+      startBootstrap(state, config, indexName, partitionId, nodeId);
+    }
+    return;
+  }
+  startBootstrap(state, config, indexName, partitionId, assignment.primary);
+}
+function handleExistingAssignment(state, config, existing, assignment, nodeId) {
+  if (existing.isPrimary && assignment.primary !== nodeId && assignment.primaryTerm > existing.primaryTerm) {
+    if (assignment.primary !== null) {
+      if (config.onPrimaryDemotion !== void 0) {
+        config.onPrimaryDemotion(existing.indexName, existing.partitionId, assignment.primary);
+      }
+      startBootstrap(state, config, existing.indexName, existing.partitionId, assignment.primary);
+    }
+    return;
+  }
+  if (assignment.primary !== null && replicaNeedsResync(state, existing, assignment, nodeId)) {
+    startBootstrap(state, config, existing.indexName, existing.partitionId, assignment.primary);
+  }
+}
+function replicaNeedsResync(state, existing, assignment, nodeId) {
+  if (assignment.state !== "ACTIVE") {
+    return false;
+  }
+  if (assignment.primary === null || assignment.primary === nodeId) {
+    return false;
+  }
+  if (!assignment.replicas.includes(nodeId)) {
+    return false;
+  }
+  if (assignment.inSyncSet.includes(nodeId)) {
+    return false;
+  }
+  return !state.activeBootstraps.has(partitionKey(existing.indexName, existing.partitionId));
+}
+function startBootstrap(state, config, indexName, partitionId, primaryNodeId) {
+  const key = partitionKey(indexName, partitionId);
+  const existingBootstrap = state.activeBootstraps.get(key);
+  if (existingBootstrap !== void 0) {
+    abortBootstrapState(existingBootstrap);
+  }
+  const bootstrapState = createBootstrapState(indexName, partitionId, primaryNodeId);
+  state.activeBootstraps.set(key, bootstrapState);
+  bootstrapPartition(
+    bootstrapState,
+    config.coordinator,
+    config.transport,
+    config.registration.nodeId,
+    config.bootstrapRetryBaseMs,
+    config.bootstrapRetryMaxMs,
+    config.bootstrapMaxRetries,
+    config.onBootstrapPartition,
     config.onError
   ).then((succeeded) => {
     if (state.activeBootstraps.get(key) === bootstrapState) {
@@ -1391,12 +1617,14 @@ function startBootstrap(state, config, indexName, partitionId, primaryNodeId) {
     }
     if (!succeeded) {
       state.trackedPartitions.delete(key);
+      void restartBootstrapWhileOutOfSync(state, config, indexName, partitionId);
     }
   }).catch(() => {
     if (state.activeBootstraps.get(key) === bootstrapState) {
       state.activeBootstraps.delete(key);
     }
     state.trackedPartitions.delete(key);
+    void restartBootstrapWhileOutOfSync(state, config, indexName, partitionId);
   });
 }
 function removeUnassignedPartitions(state, config, indexName, currentKeys) {
@@ -1413,37 +1641,122 @@ function removeUnassignedPartitions(state, config, indexName, currentKeys) {
       abortBootstrapState(activeBootstrap);
       state.activeBootstraps.delete(key);
     }
-    if (config.onRemovePartition !== void 0) {
-      config.onRemovePartition(tracked.indexName, tracked.partitionId);
+    if (config.onRemovePartition !== void 0) {
+      config.onRemovePartition(tracked.indexName, tracked.partitionId);
+    }
+  }
+}
+function stopAllocationWatcher(state) {
+  state.stopped = true;
+  if (state.unwatchAllocation !== null) {
+    state.unwatchAllocation();
+    state.unwatchAllocation = null;
+  }
+  if (state.debounceTimer !== null) {
+    clearTimeout(state.debounceTimer);
+    state.debounceTimer = null;
+  }
+  for (const [timer, resolve] of state.restartWaiters) {
+    clearTimeout(timer);
+    resolve();
+  }
+  state.restartWaiters.clear();
+  for (const bootstrapState of state.activeBootstraps.values()) {
+    abortBootstrapState(bootstrapState);
+  }
+  state.activeBootstraps.clear();
+  state.trackedPartitions.clear();
+  state.pendingTables.clear();
+}
+function processInitialAllocations(state, config, tables) {
+  for (const table of tables) {
+    processAllocationChange(state, config, table);
+  }
+}
+function waitBeforeBootstrapRestart(state, config) {
+  const delayMs = Math.min(config.bootstrapRetryMaxMs, config.bootstrapRetryBaseMs);
+  if (delayMs <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      state.restartWaiters.delete(timer);
+      resolve();
+    }, delayMs);
+    timer.unref?.();
+    state.restartWaiters.set(timer, resolve);
+  });
+}
+async function restartBootstrapWhileOutOfSync(state, config, indexName, partitionId) {
+  if (state.stopped) {
+    return;
+  }
+  await waitBeforeBootstrapRestart(state, config);
+  if (state.stopped) {
+    return;
+  }
+  const nodeId = config.registration.nodeId;
+  let table;
+  try {
+    table = await config.coordinator.getAllocation(indexName);
+  } catch (error) {
+    if (config.onError !== void 0) {
+      config.onError(error);
+    }
+    if (!state.stopped) {
+      void restartBootstrapWhileOutOfSync(state, config, indexName, partitionId);
     }
+    return;
   }
-}
-function stopAllocationWatcher(state) {
-  state.stopped = true;
-  if (state.unwatchAllocation !== null) {
-    state.unwatchAllocation();
-    state.unwatchAllocation = null;
+  if (state.stopped || table === null) {
+    return;
   }
-  if (state.debounceTimer !== null) {
-    clearTimeout(state.debounceTimer);
-    state.debounceTimer = null;
+  const assignment = table.assignments.get(partitionId);
+  if (assignment === void 0 || assignment.primary === null || assignment.primary === nodeId) {
+    return;
   }
-  for (const bootstrapState of state.activeBootstraps.values()) {
-    abortBootstrapState(bootstrapState);
+  if (!assignment.replicas.includes(nodeId) || assignment.inSyncSet.includes(nodeId)) {
+    return;
   }
-  state.activeBootstraps.clear();
-  state.trackedPartitions.clear();
-  state.pendingTables.clear();
-}
-function processInitialAllocations(state, config, tables) {
-  for (const table of tables) {
-    processAllocationChange(state, config, table);
+  if (assignment.state !== "ACTIVE" && assignment.state !== "INITIALISING" && assignment.state !== "MIGRATING") {
+    return;
   }
+  if (state.activeBootstraps.has(partitionKey(indexName, partitionId))) {
+    return;
+  }
+  startBootstrap(state, config, indexName, partitionId, assignment.primary);
+}
+
+// src/distribution/cluster/node-lifecycle/heartbeat.ts
+function createRegistrationHeartbeatState() {
+  return { timer: null, inFlight: Promise.resolve() };
+}
+function clearHeartbeatTimer(state) {
+  if (state.timer !== null) {
+    clearInterval(state.timer);
+    state.timer = null;
+  }
+}
+function startRegistrationHeartbeat(state, config) {
+  clearHeartbeatTimer(state);
+  state.timer = setInterval(() => {
+    state.inFlight = state.inFlight.then(() => config.coordinator.registerNode(config.registration)).catch((error) => {
+      if (config.onError !== void 0) {
+        config.onError(error);
+      }
+    });
+  }, config.nodeHeartbeatIntervalMs);
+  state.timer.unref?.();
+}
+async function stopRegistrationHeartbeat(state) {
+  clearHeartbeatTimer(state);
+  await state.inFlight;
 }
 
 // src/distribution/cluster/node-lifecycle/join.ts
-async function joinCluster(config, watcherState) {
+async function joinCluster(config, watcherState, heartbeatState) {
   await config.coordinator.registerNode(config.registration);
+  startRegistrationHeartbeat(heartbeatState, config);
   const initialTables = await loadInitialAllocations(config);
   processInitialAllocations(watcherState, config, initialTables);
   await startAllocationWatcher(watcherState, config);
@@ -1465,15 +1778,17 @@ async function leaveCluster(config) {
 // src/distribution/cluster/node-lifecycle/types.ts
 var DEFAULT_NODE_LIFECYCLE_CONFIG = {
   bootstrapRetryBaseMs: 1e3,
-  bootstrapRetryMaxMs: 3e4,
+  bootstrapRetryMaxMs: 5e3,
   bootstrapMaxRetries: 10,
-  allocationDebounceMs: 250
+  allocationDebounceMs: 250,
+  nodeHeartbeatIntervalMs: 1e4
 };
 
 // src/distribution/cluster/node-lifecycle/index.ts
 function createDataNodeLifecycle(config) {
   let status = "stopped";
   let watcherState = createAllocationWatcherState();
+  const heartbeatState = createRegistrationHeartbeatState();
   let operationLock = Promise.resolve();
   function withLock(fn) {
     const prev = operationLock;
@@ -1516,9 +1831,10 @@ function createDataNodeLifecycle(config) {
         }
         status = "joining";
         try {
-          await joinCluster(config, watcherState);
+          await joinCluster(config, watcherState, heartbeatState);
           status = "active";
         } catch (error) {
+          await stopRegistrationHeartbeat(heartbeatState);
           status = "stopped";
           throw error;
         }
@@ -1530,6 +1846,7 @@ function createDataNodeLifecycle(config) {
           return;
         }
         status = "leaving";
+        await stopRegistrationHeartbeat(heartbeatState);
         stopAllocationWatcher(watcherState);
         try {
           await leaveCluster(config);
@@ -1544,6 +1861,7 @@ function createDataNodeLifecycle(config) {
         if (status === "shutdown") {
           return;
         }
+        await stopRegistrationHeartbeat(heartbeatState);
         stopAllocationWatcher(watcherState);
         if (status === "active" || status === "joining") {
           try {
@@ -2818,11 +3136,47 @@ function validateLocalPartitionCount(engine, indexName, primaryNodeId, partition
 // 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 lastSeqNo = log.localLogEnd;
+  const lastPrimaryTerm = log.localLogEndPrimaryTerm;
   const newestEntry = log.getEntry(lastSeqNo);
   return { lastSeqNo, lastPrimaryTerm: newestEntry?.primaryTerm ?? lastPrimaryTerm };
 }
+var SYNCED_POSITION_REPORT_TIMEOUT_MS = 5e3;
+async function reportSyncedPosition(indexName, partitionId, target, knownSeqNo, deadline, deps) {
+  const logState = readLocalLogState(indexName, partitionId, deps);
+  if (logState.lastSeqNo <= knownSeqNo) {
+    return;
+  }
+  const budgetMs = Math.min(SYNCED_POSITION_REPORT_TIMEOUT_MS, deadline - Date.now());
+  if (budgetMs <= 0) {
+    return;
+  }
+  const payload = {
+    indexName,
+    partitionId,
+    lastSeqNo: logState.lastSeqNo,
+    lastPrimaryTerm: logState.lastPrimaryTerm
+  };
+  const request = {
+    type: ReplicationMessageTypes.SYNC_REQUEST,
+    sourceId: deps.sourceNodeId,
+    requestId: generateId(),
+    payload: encode(payload)
+  };
+  try {
+    await withDeadline(
+      deps.transport.stream(target, request, () => {
+      }),
+      budgetMs,
+      indexName,
+      "synced-position-report"
+    );
+  } catch (error) {
+    if (deps.onError !== void 0) {
+      deps.onError(error);
+    }
+  }
+}
 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,
@@ -2856,6 +3210,7 @@ async function syncFromAnyTarget(state, entry, indexName, partitionId, primaryNo
         )
       };
     }
+    const positionBeforeAttempt = readLocalLogState(indexName, partitionId, deps).lastSeqNo;
     const attempt = await syncFromTarget(
       state,
       entry,
@@ -2869,6 +3224,7 @@ async function syncFromAnyTarget(state, entry, indexName, partitionId, primaryNo
       abortCheck
     );
     if (attempt.ok) {
+      await reportSyncedPosition(indexName, partitionId, target, positionBeforeAttempt, deadline, deps);
       return attempt;
     }
     lastError = new NarsilError(attempt.error.code, attempt.error.message, {
@@ -2974,94 +3330,288 @@ async function syncFromTarget(state, entry, indexName, partitionId, target, coor
   };
 }
 
-// src/distribution/cluster-node/bootstrap-sync/live.ts
-async function resolveLivePartitionCount(coordinator, indexName, partitionId, primaryNodeId, abortPromise) {
-  try {
-    const winner = await Promise.race([coordinator.getAllocation(indexName), abortPromise]);
-    if (winner === ABORT_SENTINEL) {
-      return "aborted";
+// src/distribution/cluster-node/bootstrap-sync/live.ts
+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
+        }
+      )
+    };
+  }
+}
+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);
+  }
+  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) {
+    surfaceError(deps, indexName, primaryNodeId, dropError);
+    return null;
+  }
+  if (entry.aborted) {
+    return "aborted";
+  }
+  const schemaResult = await loadCoordinatorSchema(deps.coordinator, indexName, primaryNodeId, entry.abortPromise);
+  if (schemaResult === "aborted") {
+    return "aborted";
+  }
+  if ("error" in schemaResult) {
+    surfaceError(deps, indexName, primaryNodeId, schemaResult.error);
+    return null;
+  }
+  return schemaResult.schema;
+}
+async function applyRestore(state, entry, indexName, primaryNodeId, bytes, coordinatorSchema, deadline, deps) {
+  const remainingMs = deadline - Date.now();
+  if (remainingMs <= 0) {
+    surfaceError(
+      deps,
+      indexName,
+      primaryNodeId,
+      new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TIMEOUT, "bootstrap sync exceeded deadline before restore", {
+        indexName
+      })
+    );
+    return false;
+  }
+  const key = entryKey(indexName, entry.partitionId);
+  const generationBeforeRestore = state.generations.get(key) ?? 0;
+  if (generationBeforeRestore !== entry.generation || entry.aborted) {
+    surfaceAborted(deps, indexName, primaryNodeId);
+    return false;
+  }
+  const restoreError = await executeEngineRestore(deps.engine, indexName, primaryNodeId, bytes, remainingMs);
+  if (restoreError !== null) {
+    surfaceError(deps, indexName, primaryNodeId, restoreError);
+    return false;
+  }
+  const generationAfterRestore = state.generations.get(key) ?? 0;
+  if (generationAfterRestore !== entry.generation || entry.aborted) {
+    if (!anotherBootstrapOwnsKey(state, key, entry)) {
+      await dropRestoredIndexQuietly(deps.engine, indexName, deps);
+    }
+    surfaceAborted(deps, indexName, primaryNodeId);
+    return false;
+  }
+  const schemaError = validateRestoredSchema(deps.engine, indexName, primaryNodeId, coordinatorSchema);
+  if (schemaError !== null) {
+    await dropRestoredIndexQuietly(deps.engine, indexName, deps);
+    surfaceError(deps, indexName, primaryNodeId, schemaError);
+    return false;
+  }
+  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)) {
+    if (!await replicaResyncRequired(indexName, partitionId, deps)) {
+      return true;
     }
-    const allocation = winner;
-    if (allocation === null) {
-      return {
-        error: new NarsilError(
-          ErrorCodes.SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE,
-          `coordinator has no allocation for index '${indexName}'`,
-          { indexName, primaryNodeId }
-        )
-      };
+    clearBootstrapSyncIndex(state, indexName, partitionId);
+  }
+  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;
     }
-    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 }
-        )
-      };
+    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 (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 }
-        )
-      };
+    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);
+      }
     }
-    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
-        }
-      )
-    };
+  });
+  state.inFlight.set(key, entry);
+  return entry.promise;
+}
+async function replicaResyncRequired(indexName, partitionId, deps) {
+  const allocation = await deps.coordinator.getAllocation(indexName);
+  const assignment = allocation?.assignments.get(partitionId);
+  if (assignment === void 0) {
+    return false;
   }
+  return assignment.state === "ACTIVE" && assignment.replicas.includes(deps.sourceNodeId) && !assignment.inSyncSet.includes(deps.sourceNodeId);
 }
-async function executeLiveBootstrapSync(state, entry, indexName, partitionId, primaryNodeId, deps, deadlineMs, deadline, abortCheck) {
-  const schemaResult = await loadCoordinatorSchema(deps.coordinator, indexName, primaryNodeId, entry.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 ("error" in schemaResult) {
-    surfaceError(deps, indexName, primaryNodeId, schemaResult.error);
+  if (schemaResult === null) {
     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", {
+      new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TIMEOUT, "bootstrap sync exceeded deadline before fetching snapshot", {
         indexName,
         deadlineMs
       })
@@ -3073,254 +3623,475 @@ async function executeLiveBootstrapSync(state, entry, indexName, partitionId, pr
     surfaceError(deps, indexName, primaryNodeId, targetsResult);
     return false;
   }
-  const syncResult = await syncFromAnyTarget(
-    state,
-    entry,
+  const fetchDeps = { transport: deps.transport, sourceNodeId: deps.sourceNodeId };
+  const fetchResult = await fetchSnapshotFromAnyTarget(
     indexName,
-    partitionId,
     primaryNodeId,
     targetsResult,
-    schemaResult.schema,
-    allocationResult.partitionCount,
     deadline,
-    deps,
-    abortCheck
+    fetchDeps,
+    abortCheck,
+    partitionId
   );
-  if (!syncResult.ok) {
-    if (syncResult.error.code === ErrorCodes.SNAPSHOT_SYNC_ABORTED) {
+  if (!fetchResult.ok) {
+    if (fetchResult.code === ErrorCodes.SNAPSHOT_SYNC_ABORTED) {
       surfaceAborted(deps, indexName, primaryNodeId);
       return false;
     }
-    if (syncResult.error.details.alreadySurfaced !== true) {
-      surfaceError(deps, indexName, primaryNodeId, syncResult.error);
+    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/write-routing/assignment.ts
+function resolvePartitionId(docId, partitionCount) {
+  return fnv1a(docId) % partitionCount;
+}
+async function resolveNodeTargets(nodeId, deps) {
+  if (deps.resolveNodeTargets === void 0) {
+    return [nodeId];
+  }
+  const targets = await deps.resolveNodeTargets(nodeId);
+  return targets.length > 0 ? targets : [nodeId];
+}
+function requireAssignedPrimary(assignment, indexName, partitionId) {
+  if (assignment === void 0 || assignment.primary === null) {
+    throw new NarsilError(
+      ErrorCodes.PARTITION_UNASSIGNED,
+      `No primary assigned for partition ${partitionId} of index '${indexName}'`,
+      { indexName, partitionId }
+    );
+  }
+  return assignment;
+}
+async function resolvePrimaryAssignment(indexName, docId, deps, requireLocalPrimary) {
+  const table = await deps.coordinator.getAllocation(indexName);
+  if (table === null || table.assignments.size === 0) {
+    if (requireLocalPrimary) {
+      throw new NarsilError(
+        ErrorCodes.QUERY_ROUTING_FAILED,
+        `No allocation table is available for forwarded write to index '${indexName}'`,
+        { indexName }
+      );
+    }
+    return null;
+  }
+  const partitionCount = table.assignments.size;
+  const partitionId = resolvePartitionId(docId, partitionCount);
+  const assignment = requireAssignedPrimary(table.assignments.get(partitionId), indexName, partitionId);
+  if (requireLocalPrimary && assignment.primary !== deps.nodeId) {
+    throw new NarsilError(
+      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, pendingAdmissions = []) {
+  const configuredReplicas = new Set(assignment.replicas);
+  const targets = [];
+  for (const nodeId of [...assignment.inSyncSet, ...pendingAdmissions]) {
+    if (nodeId !== localNodeId && configuredReplicas.has(nodeId) && !targets.includes(nodeId)) {
+      targets.push(nodeId);
     }
-    return false;
   }
-  if (abortCheck()) {
-    surfaceAborted(deps, indexName, primaryNodeId);
+  return targets;
+}
+
+// src/distribution/cluster-node/catch-up/state.ts
+var CATCH_UP_TICK_MS = 1e3;
+var CATCH_UP_IN_FLIGHT_BYTE_CEILING = 67108864;
+function partitionKey2(indexName, partitionId) {
+  return `${indexName}:${partitionId}`;
+}
+function createCatchUpState() {
+  return {
+    cursors: /* @__PURE__ */ new Map(),
+    pendingAdmissions: /* @__PURE__ */ new Map(),
+    inFlightBytes: 0,
+    timer: null,
+    activeTick: null,
+    stopped: false
+  };
+}
+function recordReplicaPosition(state, indexName, partitionId, replicaNodeId, appliedSeqNo) {
+  const key = partitionKey2(indexName, partitionId);
+  const partition = state.cursors.get(key) ?? /* @__PURE__ */ new Map();
+  const existing = partition.get(replicaNodeId);
+  if (existing === void 0) {
+    partition.set(replicaNodeId, { appliedSeqNo, sending: false, syncEpoch: 0 });
+  } else if (appliedSeqNo > existing.appliedSeqNo) {
+    existing.appliedSeqNo = appliedSeqNo;
+  } else if (appliedSeqNo < existing.appliedSeqNo) {
+    existing.appliedSeqNo = appliedSeqNo;
+    existing.syncEpoch += 1;
+  }
+  state.cursors.set(key, partition);
+}
+function forgetReplica(state, indexName, partitionId, replicaNodeId) {
+  const key = partitionKey2(indexName, partitionId);
+  const partition = state.cursors.get(key);
+  if (partition !== void 0) {
+    partition.delete(replicaNodeId);
+    if (partition.size === 0) {
+      state.cursors.delete(key);
+    }
+  }
+  clearPendingAdmission(state, indexName, partitionId, replicaNodeId);
+}
+function getPendingAdmissions(state, indexName, partitionId) {
+  const pending = state.pendingAdmissions.get(partitionKey2(indexName, partitionId));
+  return pending === void 0 ? [] : [...pending];
+}
+function markPendingAdmission(state, indexName, partitionId, replicaNodeId) {
+  const key = partitionKey2(indexName, partitionId);
+  const pending = state.pendingAdmissions.get(key) ?? /* @__PURE__ */ new Set();
+  if (pending.has(replicaNodeId)) {
     return false;
   }
-  if (syncResult.snapshotHeader !== null) {
-    deps.onSnapshotApplied?.(indexName, partitionId, syncResult.snapshotHeader);
-  }
-  state.completed.add(entryKey(indexName, partitionId));
+  pending.add(replicaNodeId);
+  state.pendingAdmissions.set(key, pending);
   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) {
-    surfaceError(deps, indexName, primaryNodeId, dropError);
-    return null;
-  }
-  if (entry.aborted) {
-    return "aborted";
+function clearPendingAdmission(state, indexName, partitionId, replicaNodeId) {
+  const key = partitionKey2(indexName, partitionId);
+  const pending = state.pendingAdmissions.get(key);
+  if (pending === void 0) {
+    return;
   }
-  const schemaResult = await loadCoordinatorSchema(deps.coordinator, indexName, primaryNodeId, entry.abortPromise);
-  if (schemaResult === "aborted") {
-    return "aborted";
+  pending.delete(replicaNodeId);
+  if (pending.size === 0) {
+    state.pendingAdmissions.delete(key);
   }
-  if ("error" in schemaResult) {
-    surfaceError(deps, indexName, primaryNodeId, schemaResult.error);
-    return null;
+}
+
+// src/distribution/cluster-node/catch-up/admission.ts
+var ADMISSION_TIMEOUT_MS = 1e4;
+async function sendToController(payload, controllerNodeId, deps) {
+  const targets = await resolveNodeTargets(controllerNodeId, deps);
+  for (const target of targets) {
+    try {
+      const result = await requestInsyncAdmission(payload, target, deps.transport, deps.nodeId);
+      return result.accepted;
+    } catch (_) {
+    }
   }
-  return schemaResult.schema;
+  return false;
 }
-async function applyRestore(state, entry, indexName, primaryNodeId, bytes, coordinatorSchema, deadline, deps) {
-  const remainingMs = deadline - Date.now();
-  if (remainingMs <= 0) {
-    surfaceError(
-      deps,
-      indexName,
-      primaryNodeId,
-      new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TIMEOUT, "bootstrap sync exceeded deadline before restore", {
-        indexName
-      })
-    );
-    return false;
+function withTimeout(work, timeoutMs, fallback) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(fallback), timeoutMs);
+    timer.unref?.();
+    work.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }).catch(() => {
+      clearTimeout(timer);
+      resolve(fallback);
+    });
+  });
+}
+async function withdrawAdmission(payload, controllerNodeId, deps) {
+  const targets = await resolveNodeTargets(controllerNodeId, deps);
+  for (const target of targets) {
+    try {
+      const result = await requestInsyncRemoval(
+        payload.indexName,
+        payload.partitionId,
+        payload.replicaNodeId,
+        payload.primaryTerm,
+        target,
+        deps.transport,
+        deps.nodeId
+      );
+      if (result.accepted) {
+        return;
+      }
+    } catch (_) {
+    }
   }
-  const key = entryKey(indexName, entry.partitionId);
-  const generationBeforeRestore = state.generations.get(key) ?? 0;
-  if (generationBeforeRestore !== entry.generation || entry.aborted) {
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
+}
+async function proposeAdmission(state, deps, indexName, partitionId, assignment, replicaNodeId, cursor) {
+  const log = deps.getReplicationLog(indexName, partitionId);
+  if (cursor.appliedSeqNo < log.commitPoint) {
+    return;
   }
-  const restoreError = await executeEngineRestore(deps.engine, indexName, primaryNodeId, bytes, remainingMs);
-  if (restoreError !== null) {
-    surfaceError(deps, indexName, primaryNodeId, restoreError);
-    return false;
+  if (!markPendingAdmission(state, indexName, partitionId, replicaNodeId)) {
+    return;
   }
-  const generationAfterRestore = state.generations.get(key) ?? 0;
-  if (generationAfterRestore !== entry.generation || entry.aborted) {
-    if (!anotherBootstrapOwnsKey(state, key, entry)) {
-      await dropRestoredIndexQuietly(deps.engine, indexName, deps);
+  const proposedEpoch = cursor.syncEpoch;
+  try {
+    const controllerNodeId = await deps.coordinator.getLeaseHolder(CONTROLLER_LEASE_KEY);
+    if (controllerNodeId === null) {
+      return;
     }
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
-  }
-  const schemaError = validateRestoredSchema(deps.engine, indexName, primaryNodeId, coordinatorSchema);
-  if (schemaError !== null) {
-    await dropRestoredIndexQuietly(deps.engine, indexName, deps);
-    surfaceError(deps, indexName, primaryNodeId, schemaError);
-    return false;
+    const payload = {
+      indexName,
+      partitionId,
+      replicaNodeId,
+      primaryTerm: assignment.primaryTerm,
+      appliedSeqNo: cursor.appliedSeqNo,
+      commitPoint: log.commitPoint
+    };
+    const accepted = await withTimeout(sendToController(payload, controllerNodeId, deps), ADMISSION_TIMEOUT_MS, false);
+    if (accepted && cursor.syncEpoch !== proposedEpoch) {
+      await withTimeout(withdrawAdmission(payload, controllerNodeId, deps), ADMISSION_TIMEOUT_MS, void 0);
+    }
+  } finally {
+    clearPendingAdmission(state, indexName, partitionId, replicaNodeId);
   }
-  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;
+async function replicateToReplicas(entry, inSyncReplicas, transport, sourceNodeId, resolveNodeTargets3) {
+  const message = createEntryMessage(entry, sourceNodeId);
+  return sendAndCollectAcks(message, entry, inSyncReplicas, transport, resolveNodeTargets3);
+}
+async function replicateBatchToReplicas(entries, inSyncReplicas, transport, sourceNodeId, resolveNodeTargets3) {
+  if (entries.length === 0) {
+    return { acknowledged: [], failed: [] };
   }
-  const key = entryKey(indexName, partitionId);
-  if (state.completed.has(key)) {
-    if (!await replicaResyncRequired(indexName, partitionId, deps)) {
-      return true;
-    }
-    clearBootstrapSyncIndex(state, indexName, partitionId);
+  if (entries.length === 1) {
+    return replicateToReplicas(entries[0], inSyncReplicas, transport, sourceNodeId, resolveNodeTargets3);
   }
-  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 message = createEntryBatchMessage(entries, sourceNodeId);
+  const lastEntry = entries[entries.length - 1];
+  return sendAndCollectAcks(message, lastEntry, inSyncReplicas, transport, resolveNodeTargets3);
+}
+async function sendAndCollectAcks(message, ackEntry, inSyncReplicas, transport, resolveNodeTargets3) {
+  const uniqueReplicas = [...new Set(inSyncReplicas)];
+  if (uniqueReplicas.length === 0) {
+    return { acknowledged: [], failed: [] };
   }
-  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);
+  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, ackEntry)) {
+      acknowledged.push(replicaNodeId);
+    } else {
+      failed.push(replicaNodeId);
     }
-  });
-  state.inFlight.set(key, entry);
-  return entry.promise;
-}
-async function replicaResyncRequired(indexName, partitionId, deps) {
-  const allocation = await deps.coordinator.getAllocation(indexName);
-  const assignment = allocation?.assignments.get(partitionId);
-  if (assignment === void 0) {
-    return false;
   }
-  return assignment.state === "ACTIVE" && assignment.replicas.includes(deps.sourceNodeId) && !assignment.inSyncSet.includes(deps.sourceNodeId);
+  return { acknowledged, failed };
 }
-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;
+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;
     }
-    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);
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function isMatchingAck(response, entry) {
+  if (response.type !== ReplicationMessageTypes.ACK) {
     return false;
   }
-  if (schemaResult === null) {
+  try {
+    const payload = validateAckPayload(decode(response.payload));
+    return payload.seqNo === entry.seqNo && payload.partitionId === entry.partitionId && payload.indexName === entry.indexName;
+  } catch {
     return false;
   }
-  if (abortCheck()) {
-    surfaceAborted(deps, indexName, primaryNodeId);
+}
+
+// src/distribution/cluster-node/catch-up/pump.ts
+var ENTRY_FIXED_OVERHEAD_BYTES = 40;
+function entryBytes(entry) {
+  return ENTRY_FIXED_OVERHEAD_BYTES + entry.indexName.length + entry.documentId.length + (entry.document?.byteLength ?? 0);
+}
+function batchBytes(entries) {
+  let total = 0;
+  for (const entry of entries) {
+    total += entryBytes(entry);
+  }
+  return total;
+}
+function replicaHasFallenOutOfRetention(log, cursor) {
+  const oldest = log.oldestSeqNo;
+  if (oldest === void 0) {
     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 cursor.appliedSeqNo + 1 < oldest;
+}
+function nextWireBatch(state, pending) {
+  const chunks = chunkByBudget(pending, {
+    ...WIRE_BATCH_BUDGET,
+    payloadBytesOf: (entry) => entry.document?.byteLength ?? 0,
+    breaksRun: (entry, previous) => entry.seqNo !== previous.seqNo + 1
+  });
+  const batch = chunks[0] ?? [];
+  if (batch.length === 0) {
+    return [];
+  }
+  const available = CATCH_UP_IN_FLIGHT_BYTE_CEILING - state.inFlightBytes;
+  return batchBytes(batch) > available ? [] : batch;
+}
+async function pumpReplica(state, deps, indexName, partitionId, assignment, replicaNodeId, cursor) {
+  if (cursor.sending) {
+    return;
+  }
+  const log = deps.getReplicationLog(indexName, partitionId);
+  if (replicaHasFallenOutOfRetention(log, cursor)) {
+    forgetReplica(state, indexName, partitionId, replicaNodeId);
+    return;
+  }
+  if (cursor.appliedSeqNo >= log.localLogEnd) {
+    await proposeAdmission(state, deps, indexName, partitionId, assignment, replicaNodeId, cursor);
+    return;
+  }
+  const batch = nextWireBatch(state, log.getEntriesFrom(cursor.appliedSeqNo + 1));
+  if (batch.length === 0) {
+    return;
+  }
+  const reservedBytes = batchBytes(batch);
+  const sendingEpoch = cursor.syncEpoch;
+  cursor.sending = true;
+  state.inFlightBytes += reservedBytes;
+  try {
+    const result = await replicateBatchToReplicas(
+      batch,
+      [replicaNodeId],
+      deps.transport,
+      deps.nodeId,
+      deps.resolveNodeTargets
     );
-    return false;
+    if (result.acknowledged.includes(replicaNodeId) && cursor.syncEpoch === sendingEpoch) {
+      cursor.appliedSeqNo = batch[batch.length - 1].seqNo;
+    }
+  } finally {
+    state.inFlightBytes -= reservedBytes;
+    cursor.sending = false;
   }
-  const targetsResult = await resolveTransportTargets(indexName, primaryNodeId, deps.resolveNodeTargets);
-  if (targetsResult instanceof NarsilError) {
-    surfaceError(deps, indexName, primaryNodeId, targetsResult);
-    return false;
+}
+async function pumpPartition(state, deps, key, replicas) {
+  const separator = key.lastIndexOf(":");
+  const indexName = key.slice(0, separator);
+  const partitionId = Number(key.slice(separator + 1));
+  const table = await deps.coordinator.getAllocation(indexName);
+  const assignment = table?.assignments.get(partitionId);
+  if (assignment === void 0 || assignment.primary !== deps.nodeId) {
+    state.cursors.delete(key);
+    state.pendingAdmissions.delete(key);
+    return;
   }
-  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;
+  for (const [replicaNodeId, cursor] of [...replicas]) {
+    if (state.stopped) {
+      return;
+    }
+    if (!assignment.replicas.includes(replicaNodeId) || assignment.inSyncSet.includes(replicaNodeId)) {
+      forgetReplica(state, indexName, partitionId, replicaNodeId);
+      continue;
+    }
+    try {
+      await pumpReplica(state, deps, indexName, partitionId, assignment, replicaNodeId, cursor);
+    } catch (_) {
     }
-    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;
+}
+function runCatchUpTick(state, deps) {
+  if (state.stopped || state.activeTick !== null || state.cursors.size === 0) {
+    return state.activeTick ?? Promise.resolve();
   }
-  if (abortCheck()) {
-    if (!anotherBootstrapOwnsKey(state, key, entry)) {
-      await dropRestoredIndexQuietly(deps.engine, indexName, deps);
+  const tick = (async () => {
+    for (const [key, replicas] of [...state.cursors]) {
+      if (state.stopped) {
+        return;
+      }
+      try {
+        await pumpPartition(state, deps, key, replicas);
+      } catch (_) {
+      }
     }
-    surfaceAborted(deps, indexName, primaryNodeId);
-    return false;
+  })().finally(() => {
+    state.activeTick = null;
+  });
+  state.activeTick = tick;
+  return tick;
+}
+function startCatchUpPump(state, deps) {
+  void stopCatchUpPump(state);
+  state.stopped = false;
+  state.timer = setInterval(() => {
+    void runCatchUpTick(state, deps);
+  }, CATCH_UP_TICK_MS);
+  state.timer.unref?.();
+}
+async function stopCatchUpPump(state) {
+  state.stopped = true;
+  if (state.timer !== null) {
+    clearInterval(state.timer);
+    state.timer = null;
+  }
+  if (state.activeTick !== null) {
+    await state.activeTick;
   }
-  deps.onSnapshotApplied?.(indexName, partitionId, fetchResult.header);
-  state.completed.add(key);
-  return true;
 }
 
 // src/distribution/cluster-node/local-engine.ts
@@ -3663,21 +4434,14 @@ async function authorizeSnapshotRequest(coordinator, indexName, sourceId) {
   }
   let sawAssignment = false;
   for (const assignment of allocation.assignments.values()) {
-    const isPrimary = assignment.primary === sourceId;
-    const isReplica = assignment.replicas.includes(sourceId);
-    if (!isPrimary && !isReplica) {
+    const isAssigned = assignment.primary === sourceId || assignment.replicas.includes(sourceId);
+    if (!isAssigned) {
       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) {
@@ -3693,12 +4457,6 @@ async function authorizeSnapshotRequest(coordinator, indexName, sourceId) {
     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);
-}
 
 // src/distribution/cluster-node/snapshot-cache.ts
 var DEFAULT_MAX_CONCURRENT_SNAPSHOTS = 2;
@@ -4217,7 +4975,7 @@ var NULL_BYTE = String.fromCharCode(0);
 function throwInvalid(code, message, details) {
   throw new NarsilError(code, message, details);
 }
-function isRecord3(value) {
+function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function isInteger(value) {
@@ -4335,14 +5093,14 @@ function validateIndexNameField(value, fieldLabel) {
   return value;
 }
 function validateDocumentId(value, fieldLabel) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, `Invalid FetchPayload: "${fieldLabel}" must be an object`);
   }
   validateStringField(value.docId, `${fieldLabel}.docId`, MAX_DOC_ID_LENGTH, CONFIG_INVALID);
   validatePartitionId(value.partitionId, `${fieldLabel}.partitionId`, CONFIG_INVALID);
 }
 function validateHighlightConfig(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, 'Invalid FetchPayload: "highlight" must be an object or null');
   }
   if (value.fields !== null) {
@@ -4368,7 +5126,7 @@ function validateHighlightConfig(value) {
   }
 }
 function validateFetchPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid FetchPayload: expected an object");
   }
   validateIndexNameField(decoded.indexName, "indexName");
@@ -4394,7 +5152,7 @@ function validateFetchPayload(decoded) {
   return decoded;
 }
 function validateFetchResultPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid FetchResultPayload: expected an object");
   }
   if (!Array.isArray(decoded.documents)) {
@@ -4402,14 +5160,14 @@ function validateFetchResultPayload(decoded) {
   }
   for (let i = 0; i < decoded.documents.length; i++) {
     const doc = decoded.documents[i];
-    if (!isRecord3(doc)) {
+    if (!isRecord2(doc)) {
       throwInvalid(CONFIG_INVALID, `Invalid FetchResultPayload: "documents[${i}]" must be an object`);
     }
     validateStringField(doc.docId, `documents[${i}].docId`, MAX_DOC_ID_LENGTH, CONFIG_INVALID);
-    if (!isRecord3(doc.document)) {
+    if (!isRecord2(doc.document)) {
       throwInvalid(CONFIG_INVALID, `Invalid FetchResultPayload: "documents[${i}].document" must be an object`);
     }
-    if (doc.highlights !== null && !isRecord3(doc.highlights)) {
+    if (doc.highlights !== null && !isRecord2(doc.highlights)) {
       throwInvalid(CONFIG_INVALID, `Invalid FetchResultPayload: "documents[${i}].highlights" must be an object or null`);
     }
   }
@@ -4506,7 +5264,7 @@ function isKnownLeafKey(key) {
   return FIELD_FILTER_OPERATORS.includes(key);
 }
 function validateGeoRadius(value, fieldLabel, errorCode) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(errorCode, `Invalid payload: "${fieldLabel}" must be an object`);
   }
   validateNumericOperand(value.lat, `${fieldLabel}.lat`, errorCode);
@@ -4526,7 +5284,7 @@ function validateGeoRadius(value, fieldLabel, errorCode) {
   }
 }
 function validateGeoPolygon(value, fieldLabel, errorCode) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(errorCode, `Invalid payload: "${fieldLabel}" must be an object`);
   }
   if (!Array.isArray(value.points)) {
@@ -4542,7 +5300,7 @@ function validateGeoPolygon(value, fieldLabel, errorCode) {
   }
   for (let i = 0; i < points.length; i++) {
     const point = points[i];
-    if (!isRecord3(point)) {
+    if (!isRecord2(point)) {
       throwInvalid(errorCode, `Invalid payload: "${fieldLabel}.points[${i}]" must be an object`);
     }
     validateNumericOperand(point.lat, `${fieldLabel}.points[${i}].lat`, errorCode);
@@ -4583,7 +5341,7 @@ function validateLeafOperator(opKey, opValue, leafLabel, errorCode) {
     return;
   }
   if (opKey === "size") {
-    if (!isRecord3(opValue)) {
+    if (!isRecord2(opValue)) {
       throwInvalid(errorCode, `Invalid payload: "${opLabel}" must be an object`);
     }
     for (const [innerKey, innerValue] of Object.entries(opValue)) {
@@ -4605,7 +5363,7 @@ function validateLeafOperator(opKey, opValue, leafLabel, errorCode) {
   throwInvalid(errorCode, `Invalid payload: "${leafLabel}" contains unsupported operator "${opKey}"`);
 }
 function validateFieldFilter(value, fieldLabel, errorCode) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(errorCode, `Invalid payload: "${fieldLabel}" must be an object`);
   }
   const entries = Object.entries(value);
@@ -4623,7 +5381,7 @@ function validateFieldFilter(value, fieldLabel, errorCode) {
   }
 }
 function validateFieldsRecord(value, fieldLabel, errorCode) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(errorCode, `Invalid payload: "${fieldLabel}" must be an object`);
   }
   const entries = Object.entries(value);
@@ -4666,7 +5424,7 @@ function validateFilterExpression(value, fieldLabel, errorCode = SEARCH_INVALID_
       limit: MAX_FILTER_DEPTH
     });
   }
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(errorCode, `Invalid payload: "${fieldLabel}" must be an object`);
   }
   const entries = Object.entries(value);
@@ -4704,7 +5462,7 @@ function validateIndexNameField2(value, fieldLabel) {
   return value;
 }
 function validateVectorParams(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchPayload: "params.vector" must be an object');
   }
   validateFieldName(value.field, "params.vector.field", SEARCH_INVALID_FIELD);
@@ -4749,7 +5507,7 @@ function validateVectorParams(value) {
   }
 }
 function validateHybridParams(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchPayload: "params.hybrid" must be an object');
   }
   if (!ALLOWED_HYBRID_STRATEGIES.includes(value.strategy)) {
@@ -4769,7 +5527,7 @@ function validateHybridParams(value) {
   }
 }
 function validateGroupParams(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchPayload: "params.group" must be an object');
   }
   validateFieldName(value.field, "params.group.field", SEARCH_INVALID_FIELD);
@@ -4796,7 +5554,7 @@ function validateSortParams(value) {
   }
   for (let i = 0; i < value.length; i++) {
     const entry = value[i];
-    if (!isRecord3(entry)) {
+    if (!isRecord2(entry)) {
       throwInvalid(CONFIG_INVALID, `Invalid SearchPayload: "params.sort[${i}]" must be an object`);
     }
     validateFieldName(entry.field, `params.sort[${i}].field`, SEARCH_INVALID_FIELD);
@@ -4809,7 +5567,7 @@ function validateSortParams(value) {
   }
 }
 function validateBoostParams(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchPayload: "params.boost" must be an object or null');
   }
   const entries = Object.entries(value);
@@ -4828,16 +5586,16 @@ function validateBoostParams(value) {
   }
 }
 function validateGlobalStatsShape(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchPayload: "globalStats" must be an object or null');
   }
   if (!isFiniteNumber(value.totalDocuments) || value.totalDocuments < 0) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchPayload: "globalStats.totalDocuments" must be a non-negative number');
   }
-  if (!isRecord3(value.docFrequencies)) {
+  if (!isRecord2(value.docFrequencies)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchPayload: "globalStats.docFrequencies" must be an object');
   }
-  if (!isRecord3(value.totalFieldLengths)) {
+  if (!isRecord2(value.totalFieldLengths)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchPayload: "globalStats.totalFieldLengths" must be an object');
   }
 }
@@ -4927,18 +5685,18 @@ function validateParams(params) {
   }
 }
 function validateWireParams(params) {
-  if (!isRecord3(params)) {
+  if (!isRecord2(params)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchPayload: "params" must be an object');
   }
   validateParams(params);
 }
 function validateSearchPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid SearchPayload: expected an object");
   }
   validateIndexNameField2(decoded.indexName, "indexName");
   validatePartitionIdsArray(decoded.partitionIds, "partitionIds", CONFIG_INVALID);
-  if (!isRecord3(decoded.params)) {
+  if (!isRecord2(decoded.params)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchPayload: "params" must be an object');
   }
   validateParams(decoded.params);
@@ -4974,7 +5732,7 @@ function validateIndexNameField3(decoded, payloadLabel) {
   validateStringField(decoded.indexName, `${payloadLabel}.indexName`, 255, CONFIG_INVALID);
 }
 function validateCountPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid CountPayload: expected an object");
   }
   validateIndexNameField3(decoded, "CountPayload");
@@ -4982,7 +5740,7 @@ function validateCountPayload(decoded) {
   return decoded;
 }
 function validateCountResultPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid CountResultPayload: expected an object");
   }
   if (!Array.isArray(decoded.partitions)) {
@@ -4990,7 +5748,7 @@ function validateCountResultPayload(decoded) {
   }
   for (let i = 0; i < decoded.partitions.length; i++) {
     const entry = decoded.partitions[i];
-    if (!isRecord3(entry)) {
+    if (!isRecord2(entry)) {
       throwInvalid(CONFIG_INVALID, `Invalid CountResultPayload: "partitions[${i}]" must be an object`);
     }
     validateNonNegativeInteger(entry.partitionId, `partitions[${i}].partitionId`, MAX_COUNT_VALUE, CONFIG_INVALID);
@@ -5017,7 +5775,7 @@ function validateListSort(value) {
   }
   for (let i = 0; i < value.length; i++) {
     const entry = value[i];
-    if (!isRecord3(entry)) {
+    if (!isRecord2(entry)) {
       throwInvalid(CONFIG_INVALID, `Invalid ListPayload: "sort[${i}]" must be an object`);
     }
     validateFieldName(entry.field, `sort[${i}].field`, SEARCH_INVALID_FIELD);
@@ -5027,7 +5785,7 @@ function validateListSort(value) {
   }
 }
 function validateListPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid ListPayload: expected an object");
   }
   validateIndexNameField3(decoded, "ListPayload");
@@ -5072,7 +5830,7 @@ function validateSortValues(value, fieldLabel) {
   }
 }
 function validateListResultPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid ListResultPayload: expected an object");
   }
   if (!Array.isArray(decoded.entries)) {
@@ -5083,11 +5841,11 @@ function validateListResultPayload(decoded) {
   }
   for (let i = 0; i < decoded.entries.length; i++) {
     const entry = decoded.entries[i];
-    if (!isRecord3(entry)) {
+    if (!isRecord2(entry)) {
       throwInvalid(CONFIG_INVALID, `Invalid ListResultPayload: "entries[${i}]" must be an object`);
     }
     validateStringField(entry.docId, `entries[${i}].docId`, MAX_DOC_ID_LENGTH, CONFIG_INVALID);
-    if (!isRecord3(entry.document)) {
+    if (!isRecord2(entry.document)) {
       throwInvalid(CONFIG_INVALID, `Invalid ListResultPayload: "entries[${i}].document" must be an object`);
     }
     if (entry.sortValues !== null) {
@@ -5101,7 +5859,7 @@ function validateListResultPayload(decoded) {
   return decoded;
 }
 function validateSuggestPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid SuggestPayload: expected an object");
   }
   validateIndexNameField3(decoded, "SuggestPayload");
@@ -5111,7 +5869,7 @@ function validateSuggestPayload(decoded) {
   return decoded;
 }
 function validateSuggestResultPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid SuggestResultPayload: expected an object");
   }
   if (!Array.isArray(decoded.terms)) {
@@ -5125,7 +5883,7 @@ function validateSuggestResultPayload(decoded) {
   }
   for (let i = 0; i < decoded.terms.length; i++) {
     const entry = decoded.terms[i];
-    if (!isRecord3(entry)) {
+    if (!isRecord2(entry)) {
       throwInvalid(CONFIG_INVALID, `Invalid SuggestResultPayload: "terms[${i}]" must be an object`);
     }
     validateStringField(entry.term, `terms[${i}].term`, MAX_TERM_LENGTH, CONFIG_INVALID);
@@ -5142,7 +5900,7 @@ function validateSuggestResultPayload(decoded) {
   return decoded;
 }
 function validatePreflightPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid PreflightPayload: expected an object");
   }
   validateIndexNameField3(decoded, "PreflightPayload");
@@ -5151,7 +5909,7 @@ function validatePreflightPayload(decoded) {
   return decoded;
 }
 function validatePreflightResultPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid PreflightResultPayload: expected an object");
   }
   if (!isInteger(decoded.count) || decoded.count < 0) {
@@ -5170,7 +5928,7 @@ var MAX_FACET_FIELDS = 64;
 var MAX_FACET_BUCKETS = 1e4;
 var MAX_FACET_VALUE_LENGTH = 1024;
 function validateScoredEntry(value, fieldLabel) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, `Invalid SearchResultPayload: "${fieldLabel}" must be an object`);
   }
   if (typeof value.docId !== "string") {
@@ -5216,7 +5974,7 @@ function validateScoredEntry(value, fieldLabel) {
   }
 }
 function validatePartitionSearchResult(value, fieldLabel) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, `Invalid SearchResultPayload: "${fieldLabel}" must be an object`);
   }
   validatePartitionId(value.partitionId, `${fieldLabel}.partitionId`, CONFIG_INVALID);
@@ -5241,7 +5999,7 @@ function validatePartitionSearchResult(value, fieldLabel) {
   }
 }
 function validateFacetBucket(value, fieldLabel) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, `Invalid SearchResultPayload: "${fieldLabel}" must be an object`);
   }
   if (typeof value.value !== "string") {
@@ -5260,7 +6018,7 @@ function validateFacetBucket(value, fieldLabel) {
   return { value: value.value, count: value.count };
 }
 function validateFacets(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchResultPayload: "facets" must be an object or null');
   }
   const entries = Object.entries(value);
@@ -5291,7 +6049,7 @@ function validateFacets(value) {
   }
 }
 function validateFacetErrorBounds(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, 'Invalid SearchResultPayload: "facetErrorBounds" must be an object or null');
   }
   const entries = Object.entries(value);
@@ -5312,7 +6070,7 @@ function validateFacetErrorBounds(value) {
   }
 }
 function validateSearchResultPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid SearchResultPayload: expected an object");
   }
   if (!Array.isArray(decoded.results)) {
@@ -5339,7 +6097,7 @@ function validateIndexNameField4(value, fieldLabel) {
   return value;
 }
 function validateNumericRecord(value, fieldLabel) {
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     throwInvalid(CONFIG_INVALID, `Invalid payload: "${fieldLabel}" must be an object`);
   }
   for (const [key, entry] of Object.entries(value)) {
@@ -5352,7 +6110,7 @@ function validateNumericRecord(value, fieldLabel) {
   }
 }
 function validateStatsPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid StatsPayload: expected an object");
   }
   validateIndexNameField4(decoded.indexName, "indexName");
@@ -5361,7 +6119,7 @@ function validateStatsPayload(decoded) {
   return decoded;
 }
 function validateStatsResultPayload(decoded) {
-  if (!isRecord3(decoded)) {
+  if (!isRecord2(decoded)) {
     throwInvalid(CONFIG_INVALID, "Invalid StatsResultPayload: expected an object");
   }
   if (!isInteger(decoded.totalDocuments) || decoded.totalDocuments < 0) {
@@ -5761,10 +6519,10 @@ function toWireSortValue2(value) {
 function decideSyncTier(log, replicaLastSeqNo) {
   const oldest = log.oldestSeqNo;
   if (oldest === void 0) {
-    if (log.committedSeqNo === 0) {
+    if (log.localLogEnd === 0) {
       return replicaLastSeqNo === 0 ? "incremental" : "snapshot";
     }
-    return replicaLastSeqNo >= log.committedSeqNo ? "incremental" : "snapshot";
+    return replicaLastSeqNo >= log.localLogEnd ? "incremental" : "snapshot";
   }
   if (oldest <= replicaLastSeqNo + 1) {
     return "incremental";
@@ -5843,13 +6601,22 @@ async function handleSyncRequestMessage(message, respond, deps) {
       }
     );
   }
+  if (message.sourceId !== deps.nodeId) {
+    recordReplicaPosition(
+      deps.writeDeps.catchUp,
+      request.indexName,
+      request.partitionId,
+      message.sourceId,
+      request.lastSeqNo
+    );
+  }
   const log = deps.writeDeps.getReplicationLog(request.indexName, request.partitionId);
   const tier = decideSyncTier(log, request.lastSeqNo);
   if (tier === "incremental") {
     await sendSyncEntriesResponse(message, respond, deps, log.getEntriesFrom(request.lastSeqNo + 1));
     return;
   }
-  const snapshotSeqNo = log.committedSeqNo;
+  const snapshotSeqNo = log.localLogEnd;
   const sink = createSingleResponseSink(respond);
   await streamValidatedSnapshotRequest(
     message,
@@ -5902,76 +6669,6 @@ var DEFAULT_CAPACITY = {
   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) {
-    return [nodeId];
-  }
-  const targets = await deps.resolveNodeTargets(nodeId);
-  return targets.length > 0 ? targets : [nodeId];
-}
-function requireAssignedPrimary(assignment, indexName, partitionId) {
-  if (assignment === void 0 || assignment.primary === null) {
-    throw new NarsilError(
-      ErrorCodes.PARTITION_UNASSIGNED,
-      `No primary assigned for partition ${partitionId} of index '${indexName}'`,
-      { indexName, partitionId }
-    );
-  }
-  return assignment;
-}
-async function resolvePrimaryAssignment(indexName, docId, deps, requireLocalPrimary) {
-  const table = await deps.coordinator.getAllocation(indexName);
-  if (table === null || table.assignments.size === 0) {
-    if (requireLocalPrimary) {
-      throw new NarsilError(
-        ErrorCodes.QUERY_ROUTING_FAILED,
-        `No allocation table is available for forwarded write to index '${indexName}'`,
-        { indexName }
-      );
-    }
-    return null;
-  }
-  const partitionCount = table.assignments.size;
-  const partitionId = resolvePartitionId(docId, partitionCount);
-  const assignment = requireAssignedPrimary(table.assignments.get(partitionId), indexName, partitionId);
-  if (requireLocalPrimary && assignment.primary !== deps.nodeId) {
-    throw new NarsilError(
-      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 = [];
-  for (const nodeId of assignment.inSyncSet) {
-    if (nodeId !== localNodeId && configuredReplicas.has(nodeId)) {
-      targets.push(nodeId);
-    }
-  }
-  return targets;
-}
 function assertForwardResponse(response, indexName, primaryNodeId) {
   const decoded = decode(response.payload);
   if (response.type.endsWith(".error") || response.type === "error" || decoded.error === true) {
@@ -6039,76 +6736,6 @@ async function sendToNode(nodeId, message, deps) {
   }
   throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
-async function replicateToReplicas(entry, inSyncReplicas, transport, sourceNodeId, resolveNodeTargets3) {
-  const message = createEntryMessage(entry, sourceNodeId);
-  return sendAndCollectAcks(message, entry, inSyncReplicas, transport, resolveNodeTargets3);
-}
-async function replicateBatchToReplicas(entries, inSyncReplicas, transport, sourceNodeId, resolveNodeTargets3) {
-  if (entries.length === 0) {
-    return { acknowledged: [], failed: [] };
-  }
-  if (entries.length === 1) {
-    return replicateToReplicas(entries[0], inSyncReplicas, transport, sourceNodeId, resolveNodeTargets3);
-  }
-  const message = createEntryBatchMessage(entries, sourceNodeId);
-  const lastEntry = entries[entries.length - 1];
-  return sendAndCollectAcks(message, lastEntry, inSyncReplicas, transport, resolveNodeTargets3);
-}
-async function sendAndCollectAcks(message, ackEntry, inSyncReplicas, transport, resolveNodeTargets3) {
-  const uniqueReplicas = [...new Set(inSyncReplicas)];
-  if (uniqueReplicas.length === 0) {
-    return { acknowledged: [], failed: [] };
-  }
-  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, ackEntry)) {
-      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);
@@ -6204,17 +6831,32 @@ async function requestInsyncRemovalWithTargets(indexName, partitionId, replicaNo
   throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
 async function replicateEntry(entry, assignment, deps) {
-  const replicaTargets = getInSyncReplicaTargets(assignment, deps.nodeId);
+  const pending = getPendingAdmissions(deps.catchUp, entry.indexName, entry.partitionId);
+  const replicaTargets = getInSyncReplicaTargets(assignment, deps.nodeId, pending);
   const result = await replicateToReplicas(entry, replicaTargets, deps.transport, deps.nodeId, deps.resolveNodeTargets);
-  await removeFailedReplicasFromInsync(entry, result.failed, deps);
+  const inSyncFailures = cancelAdmissionsForFailures(entry, result.failed, assignment, deps);
+  await removeFailedReplicasFromInsync(entry, inSyncFailures, deps);
   await assertPrimaryWriteAuthority(entry, deps);
+  deps.getReplicationLog(entry.indexName, entry.partitionId).advanceCommitPoint(entry.seqNo);
+}
+function cancelAdmissionsForFailures(entry, failedReplicas, assignment, deps) {
+  const inSyncFailures = [];
+  for (const replicaNodeId of failedReplicas) {
+    if (assignment.inSyncSet.includes(replicaNodeId)) {
+      inSyncFailures.push(replicaNodeId);
+      continue;
+    }
+    clearPendingAdmission(deps.catchUp, entry.indexName, entry.partitionId, replicaNodeId);
+  }
+  return inSyncFailures;
 }
 async function replicateEntryBatch(entries, assignment, deps) {
   if (entries.length === 0) {
     return;
   }
   const lastEntry = entries[entries.length - 1];
-  const replicaTargets = getInSyncReplicaTargets(assignment, deps.nodeId);
+  const pending = getPendingAdmissions(deps.catchUp, lastEntry.indexName, lastEntry.partitionId);
+  const replicaTargets = getInSyncReplicaTargets(assignment, deps.nodeId, pending);
   const result = await replicateBatchToReplicas(
     entries,
     replicaTargets,
@@ -6222,8 +6864,10 @@ async function replicateEntryBatch(entries, assignment, deps) {
     deps.nodeId,
     deps.resolveNodeTargets
   );
-  await removeFailedReplicasFromInsync(lastEntry, result.failed, deps);
+  const inSyncFailures = cancelAdmissionsForFailures(lastEntry, result.failed, assignment, deps);
+  await removeFailedReplicasFromInsync(lastEntry, inSyncFailures, deps);
   await assertPrimaryWriteAuthority(lastEntry, deps);
+  deps.getReplicationLog(lastEntry.indexName, lastEntry.partitionId).advanceCommitPoint(lastEntry.seqNo);
 }
 function chunkReplicationEntries(items) {
   return chunkByBudget(items, {
@@ -7174,17 +7818,17 @@ async function handleForwardBatch(message, respond, deps) {
 async function handleReplicationEntry(message, respond, deps) {
   const payload = validateEntryPayload(decode(message.payload));
   const { entry } = payload;
-  const assignment = await resolveValidatedAssignment(entry, message.sourceId, deps);
-  await applyEntryToLog(entry, assignment, deps);
+  await resolveValidatedAssignment(entry, message.sourceId, deps);
+  await applyEntryToLog(entry, deps);
   await respond(createAckMessage(entry.seqNo, entry.partitionId, entry.indexName, deps.nodeId, message.requestId));
 }
 async function handleReplicationEntryBatch(message, respond, deps) {
   const payload = validateEntryBatchPayload(decode(message.payload));
   const firstEntry = payload.entries[0];
   const lastEntry = payload.entries[payload.entries.length - 1];
-  const assignment = await resolveValidatedAssignment(firstEntry, message.sourceId, deps);
+  await resolveValidatedAssignment(firstEntry, message.sourceId, deps);
   for (const entry of payload.entries) {
-    await applyEntryToLog(entry, assignment, deps);
+    await applyEntryToLog(entry, deps);
   }
   await respond(
     createAckMessage(lastEntry.seqNo, lastEntry.partitionId, lastEntry.indexName, deps.nodeId, message.requestId)
@@ -7219,23 +7863,23 @@ async function resolveValidatedAssignment(entry, sourceNodeId, deps) {
       }
     );
   }
-  if (assignment.primaryTerm !== entry.primaryTerm) {
+  if (entry.primaryTerm > assignment.primaryTerm) {
     throw new NarsilError(
       ErrorCodes.REPLICATION_TERM_MISMATCH,
-      `Replication entry term ${entry.primaryTerm} does not match allocation term ${assignment.primaryTerm}`,
+      `Replication entry term ${entry.primaryTerm} is newer than allocation term ${assignment.primaryTerm}`,
       { indexName: entry.indexName, partitionId: entry.partitionId }
     );
   }
-  if (!assignment.replicas.includes(deps.nodeId) || !assignment.inSyncSet.includes(deps.nodeId)) {
+  if (!assignment.replicas.includes(deps.nodeId)) {
     throw new NarsilError(
       ErrorCodes.REPLICATION_ENTRY_INVALID,
-      `Node '${deps.nodeId}' is not an in-sync replica for index '${entry.indexName}' partition ${entry.partitionId}`,
+      `Node '${deps.nodeId}' is not an assigned replica for index '${entry.indexName}' partition ${entry.partitionId}`,
       { indexName: entry.indexName, partitionId: entry.partitionId, nodeId: deps.nodeId }
     );
   }
   return assignment;
 }
-async function applyEntryToLog(entry, assignment, deps) {
+async function applyEntryToLog(entry, deps) {
   let log = deps.writeDeps.getReplicationLog(entry.indexName, entry.partitionId);
   const existing = log.getEntry(entry.seqNo);
   if (existing !== void 0) {
@@ -7261,7 +7905,7 @@ async function applyEntryToLog(entry, assignment, deps) {
     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);
+  const validation = validateReplicationEntry(entry, log.localLogEndPrimaryTerm, log);
   if (!validation.valid) {
     throw new NarsilError(
       validation.error ?? ErrorCodes.REPLICATION_ENTRY_INVALID,
@@ -8652,16 +9296,17 @@ function createClusterNodeOperations(deps) {
 var DEFAULT_LOG_RETENTION_BYTES = 268435456;
 
 // src/distribution/replication/log.ts
-var ENTRY_FIXED_OVERHEAD_BYTES = 40;
+var ENTRY_FIXED_OVERHEAD_BYTES2 = 40;
 function estimateEntrySize(entry) {
-  return ENTRY_FIXED_OVERHEAD_BYTES + entry.indexName.length + entry.documentId.length + (entry.document?.byteLength ?? 0);
+  return ENTRY_FIXED_OVERHEAD_BYTES2 + entry.indexName.length + entry.documentId.length + (entry.document?.byteLength ?? 0);
 }
 var computeChecksum = computeEntryChecksum;
 function createReplicationLog(partitionId, config) {
   const retentionBytes = config?.logRetentionBytes ?? DEFAULT_LOG_RETENTION_BYTES;
   let nextSeqNo = config?.startSeqNo ?? 1;
-  let committedSeqNo = nextSeqNo - 1;
-  let committedPrimaryTerm = config?.lastPrimaryTerm ?? 0;
+  let localLogEnd = nextSeqNo - 1;
+  let localLogEndPrimaryTerm = config?.lastPrimaryTerm ?? 0;
+  let commitPoint = nextSeqNo - 1;
   let entries = [];
   let headIndex = 0;
   let totalSizeBytes = 0;
@@ -8704,7 +9349,7 @@ function createReplicationLog(partitionId, config) {
     }
   }
   function assertEntryFitsRetention(entry) {
-    const entrySize = ENTRY_FIXED_OVERHEAD_BYTES + entry.indexName.length + entry.documentId.length + (entry.document?.byteLength ?? 0);
+    const entrySize = ENTRY_FIXED_OVERHEAD_BYTES2 + entry.indexName.length + entry.documentId.length + (entry.document?.byteLength ?? 0);
     if (entrySize > retentionBytes) {
       throw new NarsilError(
         ErrorCodes.REPLICATION_LOG_FULL,
@@ -8715,9 +9360,9 @@ function createReplicationLog(partitionId, config) {
   }
   function storeEntry(entry) {
     entries.push(entry);
-    if (entry.seqNo >= committedSeqNo) {
-      committedSeqNo = entry.seqNo;
-      committedPrimaryTerm = entry.primaryTerm;
+    if (entry.seqNo >= localLogEnd) {
+      localLogEnd = entry.seqNo;
+      localLogEndPrimaryTerm = entry.primaryTerm;
     }
     totalSizeBytes += estimateEntrySize(entry);
     evictOldEntries();
@@ -8820,11 +9465,20 @@ function createReplicationLog(partitionId, config) {
     verifyChecksum(entry) {
       return verifyEntryChecksum(entry);
     },
-    get committedSeqNo() {
-      return committedSeqNo;
+    get localLogEnd() {
+      return localLogEnd;
+    },
+    get localLogEndPrimaryTerm() {
+      return localLogEndPrimaryTerm;
     },
-    get committedPrimaryTerm() {
-      return committedPrimaryTerm;
+    get commitPoint() {
+      return commitPoint;
+    },
+    advanceCommitPoint(seqNo) {
+      const bounded = Math.min(seqNo, localLogEnd);
+      if (bounded > commitPoint) {
+        commitPoint = bounded;
+      }
     },
     get oldestSeqNo() {
       if (liveCount() === 0) return void 0;
@@ -8844,7 +9498,8 @@ function createReplicationLog(partitionId, config) {
       entries = [];
       headIndex = 0;
       totalSizeBytes = 0;
-      committedSeqNo = nextSeqNo - 1;
+      localLogEnd = nextSeqNo - 1;
+      commitPoint = nextSeqNo - 1;
     }
   };
 }
@@ -8875,6 +9530,7 @@ function seedReplicationLog(replicationLogs, indexName, partitionId, startSeqNo,
 
 // src/distribution/cluster-node/transport-listener.ts
 var CONTROLLER_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  ReplicationMessageTypes.INSYNC_ADD,
   ReplicationMessageTypes.INSYNC_REMOVE,
   ClusterMessageTypes.BOOTSTRAP_COMPLETE
 ]);
@@ -9022,6 +9678,7 @@ async function createClusterNode(config) {
     getReplicationLog: getReplicationLog2,
     resetReplicationLog: seedReplicationLog2,
     partitionWriteQueues: createPartitionWriteQueues(),
+    catchUp: createCatchUpState(),
     resolveNodeTargets: resolveNodeTargets3,
     waitForActiveReplicas: config.replication?.waitForActiveReplicas
   };
@@ -9092,6 +9749,7 @@ async function createClusterNode(config) {
       bootstrapRetryMaxMs: DEFAULT_NODE_LIFECYCLE_CONFIG.bootstrapRetryMaxMs,
       bootstrapMaxRetries: DEFAULT_NODE_LIFECYCLE_CONFIG.bootstrapMaxRetries,
       allocationDebounceMs: DEFAULT_NODE_LIFECYCLE_CONFIG.allocationDebounceMs,
+      nodeHeartbeatIntervalMs: DEFAULT_NODE_LIFECYCLE_CONFIG.nodeHeartbeatIntervalMs,
       onBootstrapPartition: bootstrapPartition2,
       onRemovePartition: (indexName, partitionId) => {
         clearBootstrapSyncIndex(bootstrapSyncState, indexName, partitionId);
@@ -9203,9 +9861,11 @@ async function createClusterNode(config) {
         });
         const listener = controllerTransport !== null ? controllerTransport.createHandler(dataHandler) : dataHandler;
         unregisterHandler = await config.transport.listen(listener);
+        startCatchUpPump(writeDeps.catchUp, writeDeps);
       }
     },
     async shutdown() {
+      await stopCatchUpPump(writeDeps.catchUp);
       if (isShutdown) {
         return;
       }