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

package/dist/distribution.mjs

@@ -1,6 +1,7 @@
-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 { createEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, now, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, clampLimit, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, MAX_SUGGEST_SCATTER_LIMIT, chunkByBudget, WIRE_BATCH_BUDGET, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, createEntryMessage, computeEntryChecksum, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-MMSWEEZT.mjs';
+import { ReplicationMessageTypes, TransportErrorCodes, ClusterMessageTypes, QueryMessageTypes, TransportError, MAX_MESSAGE_SIZE_BYTES } from './chunk-JQUL2T6I.mjs';
+import { validateIndexName, indexConfigKey, putIndexMetadata, getIndexMetadata, MAX_PARTITION_COUNT, MAX_INDEX_NAME_LENGTH } from './chunk-WU2UZEVD.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-GRWFY2HI.mjs';
 import './chunk-TGP5M5R7.mjs';
 import './chunk-OBXS7OZM.mjs';
 import './chunk-WDL632CN.mjs';
@@ -8,7 +9,7 @@ import { crc32 } from './chunk-KMMJMDUA.mjs';
 import './chunk-U2BKYEC7.mjs';
 import { compareCodePoints, toComparableSortValue, compareComparableKeys, compareSortValues } from './chunk-BFIH7OV5.mjs';
 import { generateId } from './chunk-WTONLDU3.mjs';
-import { ErrorCodes, NarsilError, describeError } from './chunk-EMI63EXP.mjs';
+import { ErrorCodes, NarsilError, describeError } from './chunk-GB2IIJJG.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 // src/distribution/cluster/controller/types.ts
@@ -26,6 +27,12 @@ function createElectionState() {
     standbyTimer: null
   };
 }
+function clearStandbyTimer(state) {
+  if (state.standbyTimer !== null) {
+    clearTimeout(state.standbyTimer);
+    state.standbyTimer = null;
+  }
+}
 function clearElectionTimers(state) {
   if (state.renewalTimer !== null) {
     clearInterval(state.renewalTimer);
@@ -58,7 +65,11 @@ function startRenewalInterval(state, coordinator, nodeId, ttlMs, onLeaseLost) {
   }, intervalMs);
 }
 function scheduleStandbyRetry(state, retryMs, onRetry) {
-  state.standbyTimer = setTimeout(onRetry, retryMs);
+  clearStandbyTimer(state);
+  state.standbyTimer = setTimeout(() => {
+    state.standbyTimer = null;
+    onRetry();
+  }, retryMs);
 }
 
 // src/distribution/cluster/allocator/deciders/balance.ts
@@ -237,8 +248,18 @@ function countNodeAssignments(assignments) {
   }
   return counts;
 }
+function countPrimaryAssignments(assignments) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const assignment of assignments.values()) {
+    if (assignment.primary !== null) {
+      counts.set(assignment.primary, (counts.get(assignment.primary) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
 function computeNodeWeights(nodes, assignments) {
   const assignmentCounts = countNodeAssignments(assignments);
+  const primaryCounts = countPrimaryAssignments(assignments);
   let totalCapacity = 0;
   for (const node of nodes) {
     totalCapacity += node.capacity.memoryBytes;
@@ -247,12 +268,14 @@ function computeNodeWeights(nodes, assignments) {
   const weights = [];
   for (const node of nodes) {
     const partitionCount = assignmentCounts.get(node.nodeId) ?? 0;
+    const primaryCount = primaryCounts.get(node.nodeId) ?? 0;
     const normalizedCapacity = averageCapacity > 0 ? node.capacity.memoryBytes / averageCapacity : 1;
-    const weight = partitionCount / normalizedCapacity;
     weights.push({
       nodeId: node.nodeId,
-      weight,
+      weight: partitionCount / normalizedCapacity,
       partitionCount,
+      primaryWeight: primaryCount / normalizedCapacity,
+      primaryCount,
       capacity: node.capacity.memoryBytes
     });
   }
@@ -271,6 +294,11 @@ function findBestNode(candidates, weights, deciders, context) {
   const sorted = [...candidates].sort((a, b) => {
     const wA = weightByNodeId.get(a);
     const wB = weightByNodeId.get(b);
+    if (context.role === "primary") {
+      const primaryA = wA?.primaryWeight ?? 0;
+      const primaryB = wB?.primaryWeight ?? 0;
+      if (primaryA !== primaryB) return primaryA - primaryB;
+    }
     const weightA = wA?.weight ?? 0;
     const weightB = wB?.weight ?? 0;
     if (weightA !== weightB) return weightA - weightB;
@@ -380,6 +408,90 @@ function initialAllocate(nodes, indexName, partitionCount, replicationFactor, co
   };
 }
 
+// src/distribution/cluster/last-holders.ts
+function lastHoldersOf(assignment) {
+  return assignment.lastHolders ?? [];
+}
+function holdsLastCopy(assignment, nodeId) {
+  return lastHoldersOf(assignment).includes(nodeId);
+}
+
+// src/distribution/cluster/allocator/leadership.ts
+var LEADERSHIP_IMBALANCE_THRESHOLD = 2;
+function loadOf(nodeId, counts, shares) {
+  const share = shares.get(nodeId);
+  return (counts.get(nodeId) ?? 0) / (share === void 0 || share <= 0 ? 1 : share);
+}
+function heaviestLeader(shares, counts, withoutHandover) {
+  let heaviest;
+  for (const nodeId of shares.keys()) {
+    if (withoutHandover.has(nodeId)) {
+      continue;
+    }
+    if (heaviest === void 0 || loadOf(nodeId, counts, shares) > loadOf(heaviest, counts, shares)) {
+      heaviest = nodeId;
+    }
+  }
+  return heaviest;
+}
+function findSwap(assignments, heaviest, counts, shares) {
+  const heaviestLoad = loadOf(heaviest, counts, shares);
+  let best = null;
+  for (const assignment of assignments.values()) {
+    if (assignment.state !== "ACTIVE" || assignment.primary !== heaviest) {
+      continue;
+    }
+    for (const candidateNodeId of assignment.inSyncSet) {
+      const candidateLoad = loadOf(candidateNodeId, counts, shares);
+      if (heaviestLoad - candidateLoad < LEADERSHIP_IMBALANCE_THRESHOLD) {
+        continue;
+      }
+      if (best === null || candidateLoad < best.candidateLoad) {
+        best = { assignment, candidateNodeId, candidateLoad };
+      }
+    }
+  }
+  return best;
+}
+function applySwap(swap, previousPrimary) {
+  const { assignment, candidateNodeId } = swap;
+  assignment.primary = candidateNodeId;
+  assignment.replicas = [...assignment.replicas.filter((nodeId) => nodeId !== candidateNodeId), previousPrimary];
+  assignment.inSyncSet = [
+    ...assignment.inSyncSet.filter((nodeId) => nodeId !== candidateNodeId && nodeId !== previousPrimary),
+    previousPrimary
+  ];
+  assignment.primaryTerm += 1;
+}
+function rebalanceLeadership(assignments, shares) {
+  const withoutHandover = /* @__PURE__ */ new Set();
+  for (let swaps = 0; swaps < assignments.size; swaps++) {
+    const counts = countPrimaryAssignments(assignments);
+    const heaviest = heaviestLeader(shares, counts, withoutHandover);
+    if (heaviest === void 0) {
+      return;
+    }
+    const swap = findSwap(assignments, heaviest, counts, shares);
+    if (swap === null) {
+      withoutHandover.add(heaviest);
+      continue;
+    }
+    applySwap(swap, heaviest);
+  }
+}
+function capacityShares(nodes) {
+  const shares = /* @__PURE__ */ new Map();
+  let totalCapacity = 0;
+  for (const node of nodes) {
+    totalCapacity += node.capacity.memoryBytes;
+  }
+  const averageCapacity = nodes.length > 0 ? totalCapacity / nodes.length : 0;
+  for (const node of nodes) {
+    shares.set(node.nodeId, averageCapacity > 0 ? node.capacity.memoryBytes / averageCapacity : 1);
+  }
+  return shares;
+}
+
 // src/distribution/cluster/allocator/rebalance.ts
 function cloneAssignments(assignments) {
   const cloned = /* @__PURE__ */ new Map();
@@ -390,20 +502,55 @@ function cloneAssignments(assignments) {
       inSyncSet: [...assignment.inSyncSet],
       commitPoint: assignment.commitPoint,
       state: assignment.state,
-      primaryTerm: assignment.primaryTerm
+      primaryTerm: assignment.primaryTerm,
+      ...assignment.lastHolders !== void 0 ? { lastHolders: [...assignment.lastHolders] } : {},
+      ...assignment.unassignedReason !== void 0 ? { unassignedReason: assignment.unassignedReason } : {}
     });
   }
   return cloned;
 }
-function markUnassigned(assignment) {
+function markUnassigned(assignment, lastPrimary, lastInSyncSet) {
+  const holders = new Set(lastHoldersOf(assignment));
+  for (const nodeId of lastInSyncSet) {
+    holders.add(nodeId);
+  }
+  if (lastPrimary !== null) {
+    holders.add(lastPrimary);
+  }
   assignment.primary = null;
   assignment.replicas = [];
   assignment.inSyncSet = [];
+  assignment.lastHolders = [...holders].sort(compareCodePoints);
   assignment.state = "UNASSIGNED";
 }
-function handleLostNodes(assignments, activeNodeIds) {
+function primaryLoadOf(nodeId, primaryCounts, shares) {
+  const share = shares.get(nodeId);
+  return (primaryCounts.get(nodeId) ?? 0) / (share === void 0 || share <= 0 ? 1 : share);
+}
+function leastLoadedCandidate(candidates, primaryCounts, shares) {
+  let best;
+  for (const candidate of candidates) {
+    if (best === void 0) {
+      best = candidate;
+      continue;
+    }
+    const bestLoad = primaryLoadOf(best, primaryCounts, shares);
+    const candidateLoad = primaryLoadOf(candidate, primaryCounts, shares);
+    if (candidateLoad < bestLoad || candidateLoad === bestLoad && candidate < best) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+function handleLostNodes(assignments, activeNodeIds, shares) {
+  const primaryCounts = countPrimaryAssignments(assignments);
   for (const assignment of assignments.values()) {
-    const primaryWasLost = assignment.primary !== null && !activeNodeIds.has(assignment.primary);
+    if (assignment.state === "UNASSIGNED") {
+      continue;
+    }
+    const lastPrimary = assignment.primary;
+    const lastInSyncSet = [...assignment.inSyncSet];
+    const primaryWasLost = lastPrimary !== null && !activeNodeIds.has(lastPrimary);
     if (primaryWasLost) {
       assignment.primary = null;
     }
@@ -411,16 +558,21 @@ function handleLostNodes(assignments, activeNodeIds) {
     assignment.inSyncSet = assignment.inSyncSet.filter((id) => activeNodeIds.has(id));
     if (!primaryWasLost) {
       if (assignment.primary === null) {
-        markUnassigned(assignment);
+        markUnassigned(assignment, lastPrimary, lastInSyncSet);
       }
       continue;
     }
     const inSyncCandidates = assignment.replicas.filter((id) => assignment.inSyncSet.includes(id));
     if (inSyncCandidates.length === 0) {
-      markUnassigned(assignment);
+      markUnassigned(assignment, lastPrimary, lastInSyncSet);
       continue;
     }
-    const promoted = inSyncCandidates[0];
+    const promoted = leastLoadedCandidate(inSyncCandidates, primaryCounts, shares);
+    if (promoted === void 0) {
+      markUnassigned(assignment, lastPrimary, lastInSyncSet);
+      continue;
+    }
+    primaryCounts.set(promoted, (primaryCounts.get(promoted) ?? 0) + 1);
     assignment.primary = promoted;
     assignment.replicas = assignment.replicas.filter((id) => id !== promoted);
     assignment.inSyncSet = assignment.inSyncSet.filter((id) => id !== promoted);
@@ -453,7 +605,16 @@ function fillReplicaSlots(assignments, sortedNodes, nodeMap, replicationFactor,
     }
   }
 }
-function rebalanceForBalance(assignments, sortedNodes, nodeMap, constraints, deciders) {
+function slotWeightOf(nodeId, shares) {
+  const share = shares.get(nodeId);
+  return 1 / (share === void 0 || share <= 0 ? 1 : share);
+}
+function moveNarrowsGap(mostLoaded, leastLoaded, shares) {
+  const gap = mostLoaded.weight - leastLoaded.weight;
+  const afterMove = Math.abs(gap - slotWeightOf(mostLoaded.nodeId, shares) - slotWeightOf(leastLoaded.nodeId, shares));
+  return afterMove < gap;
+}
+function rebalanceForBalance(assignments, sortedNodes, nodeMap, constraints, deciders, shares) {
   let totalSlots = 0;
   for (const assignment of assignments.values()) {
     if (assignment.primary !== null) totalSlots++;
@@ -469,35 +630,73 @@ function rebalanceForBalance(assignments, sortedNodes, nodeMap, constraints, dec
     if (mostLoaded.weight - leastLoaded.weight < REBALANCE_THRESHOLD) {
       break;
     }
-    let moved = false;
-    for (const [partitionId, assignment] of assignments) {
-      if (moved) break;
-      const replicaIndex = assignment.replicas.indexOf(mostLoaded.nodeId);
-      if (replicaIndex >= 0) {
-        const removedReplica = assignment.replicas[replicaIndex];
-        assignment.replicas.splice(replicaIndex, 1);
-        const nodeAssignmentCounts = countNodeAssignments(assignments);
-        const moveContext = {
-          partitionId,
-          role: "replica",
-          currentAssignment: assignment,
-          allAssignments: assignments,
-          nodeAssignmentCounts,
-          nodes: nodeMap,
-          constraints
-        };
-        const target = findBestNode([leastLoaded.nodeId], weights, deciders, moveContext);
-        if (target !== null) {
-          assignment.replicas.push(target);
-          moved = true;
-        } else {
-          assignment.replicas.splice(replicaIndex, 0, removedReplica);
-        }
-      }
+    if (!moveNarrowsGap(mostLoaded, leastLoaded, shares)) {
+      break;
     }
+    const move = {
+      fromNodeId: mostLoaded.nodeId,
+      toNodeId: leastLoaded.nodeId,
+      weights,
+      nodeMap,
+      constraints,
+      deciders
+    };
+    const laggingFirst = moveOneReplica(assignments, move, true);
+    const moved = laggingFirst || moveOneReplica(assignments, move, false);
     if (!moved) break;
   }
 }
+function moveOneReplica(assignments, move, laggingOnly) {
+  for (const [partitionId, assignment] of assignments) {
+    const replicaIndex = assignment.replicas.indexOf(move.fromNodeId);
+    if (replicaIndex < 0) {
+      continue;
+    }
+    if (laggingOnly && assignment.inSyncSet.includes(move.fromNodeId)) {
+      continue;
+    }
+    const removedReplica = assignment.replicas[replicaIndex];
+    assignment.replicas.splice(replicaIndex, 1);
+    const moveContext = {
+      partitionId,
+      role: "replica",
+      currentAssignment: assignment,
+      allAssignments: assignments,
+      nodeAssignmentCounts: countNodeAssignments(assignments),
+      nodes: move.nodeMap,
+      constraints: move.constraints
+    };
+    const target = findBestNode([move.toNodeId], move.weights, move.deciders, moveContext);
+    if (target === null) {
+      assignment.replicas.splice(replicaIndex, 0, removedReplica);
+      continue;
+    }
+    assignment.replicas.push(target);
+    return true;
+  }
+  return false;
+}
+function clearRecoveryStateOnServedPartitions(assignments) {
+  for (const assignment of assignments.values()) {
+    if (assignment.state !== "UNASSIGNED") {
+      delete assignment.unassignedReason;
+    }
+    if (assignment.state === "ACTIVE") {
+      delete assignment.lastHolders;
+    }
+  }
+}
+function pruneInSyncSets(assignments) {
+  for (const assignment of assignments.values()) {
+    if (assignment.state === "UNASSIGNED") {
+      continue;
+    }
+    const stale = assignment.inSyncSet.some((nodeId) => !assignment.replicas.includes(nodeId));
+    if (stale) {
+      assignment.inSyncSet = assignment.inSyncSet.filter((nodeId) => assignment.replicas.includes(nodeId));
+    }
+  }
+}
 function rebalanceAllocate(nodes, currentTable, constraints, deciders) {
   const sortedNodes = [...nodes].sort((a, b) => {
     if (a.nodeId < b.nodeId) return -1;
@@ -510,9 +709,13 @@ function rebalanceAllocate(nodes, currentTable, constraints, deciders) {
     nodeMap.set(node.nodeId, node);
   }
   const assignments = cloneAssignments(currentTable.assignments);
-  handleLostNodes(assignments, activeNodeIds);
+  const shares = capacityShares(sortedNodes);
+  handleLostNodes(assignments, activeNodeIds, shares);
   fillReplicaSlots(assignments, sortedNodes, nodeMap, currentTable.replicationFactor, constraints, deciders);
-  rebalanceForBalance(assignments, sortedNodes, nodeMap, constraints, deciders);
+  rebalanceForBalance(assignments, sortedNodes, nodeMap, constraints, deciders, shares);
+  rebalanceLeadership(assignments, shares);
+  pruneInSyncSets(assignments);
+  clearRecoveryStateOnServedPartitions(assignments);
   const warnings = collectReplicationWarnings(assignments, currentTable.replicationFactor);
   return {
     table: {
@@ -561,7 +764,268 @@ function allocate(nodes, currentTable, indexName, partitionCount, replicationFac
   return rebalanceAllocate(dataNodes, currentTable, constraints, deciders);
 }
 
+// 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);
+}
+
+// src/distribution/cluster/partition-stores.ts
+function validatePartitionStoresPayload(decoded) {
+  if (!isRecord(decoded)) {
+    return null;
+  }
+  if (typeof decoded.indexName !== "string" || decoded.indexName.length === 0) {
+    return null;
+  }
+  return { indexName: decoded.indexName };
+}
+function validatePartitionStoresResultPayload(decoded) {
+  if (!isRecord(decoded)) {
+    return null;
+  }
+  if (typeof decoded.indexName !== "string" || decoded.indexName.length === 0) {
+    return null;
+  }
+  if (decoded.indexUuid !== null && typeof decoded.indexUuid !== "string") {
+    return null;
+  }
+  if (!Array.isArray(decoded.partitionIds)) {
+    return null;
+  }
+  const partitionIds = [];
+  for (const partitionId of decoded.partitionIds) {
+    if (typeof partitionId !== "number" || !Number.isInteger(partitionId) || partitionId < 0) {
+      return null;
+    }
+    partitionIds.push(partitionId);
+  }
+  return { indexName: decoded.indexName, indexUuid: decoded.indexUuid, partitionIds };
+}
+function createPartitionStoresMessage(payload, sourceNodeId, requestId) {
+  return {
+    type: ClusterMessageTypes.PARTITION_STORES,
+    sourceId: sourceNodeId,
+    requestId,
+    payload: encode(payload)
+  };
+}
+function createPartitionStoresResultMessage(result, sourceNodeId, requestId) {
+  return {
+    type: ClusterMessageTypes.PARTITION_STORES,
+    sourceId: sourceNodeId,
+    requestId,
+    payload: encode(result)
+  };
+}
+
+// src/distribution/cluster/controller/event-loop/unassigned-recovery.ts
+var RECOVERY_CAS_ATTEMPTS = 5;
+var PARTITION_STORES_TIMEOUT_MS = 5e3;
+function liveHoldersOfUnassignedPartitions(table, liveNodeIds) {
+  const holders = /* @__PURE__ */ new Set();
+  for (const assignment of table.assignments.values()) {
+    if (assignment.state !== "UNASSIGNED") {
+      continue;
+    }
+    for (const nodeId of lastHoldersOf(assignment)) {
+      if (liveNodeIds.has(nodeId)) {
+        holders.add(nodeId);
+      }
+    }
+  }
+  return [...holders].sort(compareCodePoints);
+}
+function hasRecoverablePartition(table) {
+  for (const assignment of table.assignments.values()) {
+    if (assignment.state === "UNASSIGNED" && lastHoldersOf(assignment).length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function reasonFor(assignment, liveNodeIds, answers) {
+  const holders = lastHoldersOf(assignment);
+  if (holders.length === 0) {
+    return void 0;
+  }
+  if (holders.some((nodeId) => !liveNodeIds.has(nodeId))) {
+    return "HOLDER_OFFLINE";
+  }
+  const given = holders.map((nodeId) => answers.get(nodeId));
+  if (given.some((answer) => answer === void 0 || answer.kind === "unreachable")) {
+    return "HOLDER_UNREACHABLE";
+  }
+  if (given.some((answer) => answer?.kind === "identityMismatch")) {
+    return "HOLDER_IDENTITY_MISMATCH";
+  }
+  return "HOLDER_WITHOUT_DATA";
+}
+function targetsFor(deps, targetNodeId) {
+  const targets = [targetNodeId];
+  const address = deps.addressByNodeId.get(targetNodeId);
+  if (address !== void 0 && address.length > 0 && address !== targetNodeId) {
+    targets.push(address);
+  }
+  return targets;
+}
+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 sendToFirstReachableTarget(deps, targetNodeId, message) {
+  for (const target of targetsFor(deps, targetNodeId)) {
+    const response = await withTimeout(deps.transport.send(target, message), PARTITION_STORES_TIMEOUT_MS, null);
+    if (response !== null) {
+      return response;
+    }
+  }
+  return null;
+}
+async function askNodeForStores(deps, targetNodeId, indexName, indexUuid) {
+  const message = createPartitionStoresMessage({ indexName }, deps.controllerNodeId, generateId());
+  const response = await sendToFirstReachableTarget(deps, targetNodeId, message);
+  if (response === null) {
+    return { kind: "unreachable" };
+  }
+  let answer;
+  try {
+    answer = validatePartitionStoresResultPayload(decode(response.payload));
+  } catch (_) {
+    return { kind: "unreachable" };
+  }
+  if (answer === null || answer.indexName !== indexName) {
+    return { kind: "unreachable" };
+  }
+  if (answer.indexUuid !== indexUuid) {
+    return { kind: "identityMismatch" };
+  }
+  return { kind: "held", partitionIds: new Set(answer.partitionIds) };
+}
+function promoteAssignment(assignment, nodeId) {
+  const promoted = {
+    ...assignment,
+    primary: nodeId,
+    replicas: [],
+    inSyncSet: [],
+    primaryTerm: assignment.primaryTerm + 1,
+    state: "INITIALISING"
+  };
+  delete promoted.unassignedReason;
+  return promoted;
+}
+function holderThatAnswered(assignment, partitionId, answers) {
+  const holders = [...lastHoldersOf(assignment)].sort(compareCodePoints);
+  return holders.find((nodeId) => {
+    const answer = answers.get(nodeId);
+    return answer?.kind === "held" && answer.partitionIds.has(partitionId);
+  });
+}
+function rewriteAssignment(assignment, partitionId, liveNodeIds, answers) {
+  const holder = holderThatAnswered(assignment, partitionId, answers);
+  if (holder !== void 0) {
+    return { assignment: promoteAssignment(assignment, holder), promoted: true };
+  }
+  const reason = reasonFor(assignment, liveNodeIds, answers);
+  if (reason === assignment.unassignedReason) {
+    return null;
+  }
+  if (reason === void 0) {
+    const cleared = { ...assignment };
+    delete cleared.unassignedReason;
+    return { assignment: cleared, promoted: false };
+  }
+  return { assignment: { ...assignment, unassignedReason: reason }, promoted: false };
+}
+async function writeRecoveryOutcome(deps, indexName, liveNodeIds, answers) {
+  for (let attempt = 0; attempt < RECOVERY_CAS_ATTEMPTS; attempt++) {
+    if (!deps.isActive()) {
+      return false;
+    }
+    const table = await deps.coordinator.getAllocation(indexName);
+    if (table === null) {
+      return false;
+    }
+    const rewritten = /* @__PURE__ */ new Map();
+    let anyPromoted = false;
+    for (const [partitionId, assignment] of table.assignments) {
+      if (assignment.state !== "UNASSIGNED") {
+        continue;
+      }
+      const outcome = rewriteAssignment(assignment, partitionId, liveNodeIds, answers);
+      if (outcome === null) {
+        continue;
+      }
+      rewritten.set(partitionId, outcome.assignment);
+      anyPromoted = anyPromoted || outcome.promoted;
+    }
+    if (rewritten.size === 0) {
+      return false;
+    }
+    const assignments = new Map(table.assignments);
+    for (const [partitionId, assignment] of rewritten) {
+      assignments.set(partitionId, assignment);
+    }
+    if (!deps.isActive()) {
+      return false;
+    }
+    const written = await deps.coordinator.putAllocation(
+      indexName,
+      { ...table, version: table.version + 1, assignments },
+      table.version
+    );
+    if (written) {
+      return anyPromoted;
+    }
+  }
+  return false;
+}
+async function recoverUnassignedPartitions(coordinator, transport, indexName, controllerNodeId, nodes, isActive) {
+  const addressByNodeId = new Map(nodes.map((node) => [node.nodeId, node.address]));
+  const liveNodeIds = new Set(addressByNodeId.keys());
+  const deps = { coordinator, transport, controllerNodeId, addressByNodeId, isActive };
+  if (!isActive()) {
+    return false;
+  }
+  const table = await coordinator.getAllocation(indexName);
+  if (table === null) {
+    return false;
+  }
+  if (!hasRecoverablePartition(table) || !isActive()) {
+    return false;
+  }
+  const answers = /* @__PURE__ */ new Map();
+  const candidateNodeIds = liveHoldersOfUnassignedPartitions(table, liveNodeIds);
+  if (candidateNodeIds.length > 0) {
+    const metadata = await getIndexMetadata(coordinator, indexName);
+    if (metadata === null || !isActive()) {
+      return false;
+    }
+    const given = await Promise.all(
+      candidateNodeIds.map((nodeId) => askNodeForStores(deps, nodeId, indexName, metadata.indexUuid))
+    );
+    for (let index = 0; index < candidateNodeIds.length; index += 1) {
+      answers.set(candidateNodeIds[index], given[index]);
+    }
+  }
+  return writeRecoveryOutcome(deps, indexName, liveNodeIds, answers);
+}
+
 // src/distribution/cluster/controller/event-loop/allocation.ts
+function holdsDataNode(nodes) {
+  return nodes.some((node) => node.roles.includes("data"));
+}
 var ALLOCATION_CAS_ATTEMPTS = 5;
 var ALLOCATION_RETRY_DELAY_MS = 1e3;
 var TEARDOWN_CAS_ATTEMPTS = 5;
@@ -603,12 +1067,29 @@ async function runAllocatorForIndex(coordinator, indexName, nodes, isActive, att
     { indexName, attempts: ALLOCATION_CAS_ATTEMPTS }
   );
 }
+async function recoverIndexPartitions(state, coordinator, indexName, nodes, isActive) {
+  const { transport, controllerNodeId } = state;
+  if (transport === null || controllerNodeId === null) {
+    return;
+  }
+  const promoted = await recoverUnassignedPartitions(
+    coordinator,
+    transport,
+    indexName,
+    controllerNodeId,
+    nodes,
+    isActive
+  );
+  if (promoted) {
+    await runAllocatorForIndex(coordinator, indexName, nodes, isActive);
+  }
+}
 async function runAllocatorForAllIndexes(state, coordinator, isActive, onError) {
   if (!isActive()) {
     return;
   }
   const nodes = await coordinator.listNodes();
-  if (nodes.length === 0 || !isActive()) {
+  if (!holdsDataNode(nodes) || !isActive()) {
     return;
   }
   let anyIndexFailed = false;
@@ -618,6 +1099,7 @@ async function runAllocatorForAllIndexes(state, coordinator, isActive, onError)
     }
     try {
       await runAllocatorForIndex(coordinator, indexName, nodes, isActive);
+      await recoverIndexPartitions(state, coordinator, indexName, nodes, isActive);
     } catch (error) {
       anyIndexFailed = true;
       if (onError !== void 0) {
@@ -653,7 +1135,7 @@ async function handleSchemaCreated(indexName, coordinator, knownIndexes, isActiv
     return;
   }
   const nodes = await coordinator.listNodes();
-  if (nodes.length === 0 || !isActive()) {
+  if (!holdsDataNode(nodes) || !isActive()) {
     return;
   }
   const storedTable = await coordinator.getAllocation(indexName);
@@ -744,14 +1226,6 @@ async function handleSchemaEvent(event, coordinator, state, isActive, onError) {
     await tearDownAllocation(event.indexName, coordinator, state, isActive, 0, onError);
   }
 }
-
-// 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" };
@@ -807,6 +1281,9 @@ async function requestInsyncRemoval(indexName, partitionId, replicaNodeId, prima
 }
 function handleInsyncRemoval(payload, coordinator) {
   return updateInsyncSet(payload, coordinator, (assignment) => {
+    if (assignment.state === "UNASSIGNED") {
+      return REFUSE;
+    }
     if (!assignment.inSyncSet.includes(payload.replicaNodeId)) {
       return ACCEPT;
     }
@@ -940,15 +1417,6 @@ async function handleBootstrapCompleteMessage(message, respond, coordinator, con
   });
 }
 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);
@@ -968,13 +1436,10 @@ async function processBootstrapComplete(payload, coordinator) {
     if (assignment.state !== "INITIALISING") {
       return false;
     }
-    const baseInSyncSet = assignment.inSyncSet.includes(payload.nodeId) ? assignment.inSyncSet : [...assignment.inSyncSet, payload.nodeId];
+    const served = { ...assignment, state: "ACTIVE" };
+    delete served.lastHolders;
     const updatedAssignments = new Map(table.assignments);
-    updatedAssignments.set(payload.partitionId, {
-      ...assignment,
-      state: "ACTIVE",
-      inSyncSet: ensurePrimaryInSyncSet(assignment, baseInSyncSet)
-    });
+    updatedAssignments.set(payload.partitionId, served);
     const written = await coordinator.putAllocation(
       payload.indexName,
       { ...table, version: table.version + 1, assignments: updatedAssignments },
@@ -1086,7 +1551,7 @@ function handleInsyncRemoveMessage(state, message, respond, coordinator, nodeId,
     await respond(createInsyncConfirmMessage(confirmPayload, nodeId, message.requestId));
   });
 }
-function handleInsyncAddMessage(state, message, respond, coordinator, nodeId, isActive) {
+function handleInsyncAddMessage(state, message, respond, coordinator, nodeId, isActive, onError) {
   const decoded = decodeMessage(message);
   const payload = validateInsyncAddPayload(decoded);
   if (payload === null) {
@@ -1106,6 +1571,9 @@ function handleInsyncAddMessage(state, message, respond, coordinator, nodeId, is
     }
     const confirmPayload = await handleInsyncAdmission(payload, coordinator);
     await respond(createInsyncConfirmMessage(confirmPayload, nodeId, message.requestId));
+    if (confirmPayload.accepted && isActive()) {
+      scheduleDebouncedAllocation(state, coordinator, isActive, onError);
+    }
   });
 }
 function handleQueuedBootstrapComplete(state, message, respond, coordinator, nodeId, isActive) {
@@ -1126,7 +1594,9 @@ function createEventLoopState(initialIndexNames) {
     knownIndexes: new Set(initialIndexNames),
     debounceTimer: null,
     teardownTimers: /* @__PURE__ */ new Map(),
-    insyncQueue: Promise.resolve()
+    insyncQueue: Promise.resolve(),
+    transport: null,
+    controllerNodeId: null
   };
 }
 function clearEventLoopWatchers(state) {
@@ -1155,6 +1625,8 @@ function clearEventLoopWatchers(state) {
 // src/distribution/cluster/controller/event-loop/index.ts
 async function startEventLoop(state, coordinator, transport, nodeId, isActive, onError) {
   clearEventLoopWatchers(state);
+  state.transport = transport;
+  state.controllerNodeId = nodeId;
   try {
     state.unwatchNodes = await coordinator.watchNodes((_event) => {
       scheduleDebouncedAllocation(state, coordinator, isActive, onError);
@@ -1173,7 +1645,7 @@ async function startEventLoop(state, coordinator, transport, nodeId, isActive, o
       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);
+        handleInsyncAddMessage(state, message, respond, coordinator, nodeId, isActive, onError);
       } else if (message.type === ClusterMessageTypes.BOOTSTRAP_COMPLETE) {
         handleQueuedBootstrapComplete(state, message, respond, coordinator, nodeId, isActive);
       }
@@ -1187,13 +1659,21 @@ async function startEventLoop(state, coordinator, transport, nodeId, isActive, o
 
 // src/distribution/cluster/controller/index.ts
 function createController(config) {
-  const { nodeId, coordinator, transport, leaseTtlMs, standbyRetryMs, knownIndexNames, onError } = config;
+  const { nodeId, coordinator, transport, leaseTtlMs, standbyRetryMs, knownIndexNames, onError, onElectionError } = config;
   let electionState = createElectionState();
   let eventLoopState = createEventLoopState(knownIndexNames);
   let stopped = false;
   function isActive() {
     return electionState.active;
   }
+  function standBy() {
+    if (stopped) {
+      return;
+    }
+    scheduleStandbyRetry(electionState, standbyRetryMs, () => {
+      void runElection();
+    });
+  }
   function stepDown() {
     if (!electionState.active) {
       return;
@@ -1201,12 +1681,7 @@ function createController(config) {
     electionState.active = false;
     clearElectionTimers(electionState);
     clearEventLoopWatchers(eventLoopState);
-    if (!stopped) {
-      scheduleStandbyRetry(electionState, standbyRetryMs, () => {
-        tryElection().catch(() => {
-        });
-      });
-    }
+    standBy();
   }
   async function becomeActive() {
     if (electionState.active) {
@@ -1232,18 +1707,38 @@ function createController(config) {
       throw error;
     }
   }
-  async function tryElection() {
+  async function standForElection() {
     if (stopped) {
       return;
     }
     const acquired = await tryAcquireLease(coordinator, nodeId, leaseTtlMs);
+    if (stopped) {
+      if (acquired) {
+        await releaseLease(coordinator);
+      }
+      return;
+    }
     if (acquired) {
       await becomeActive();
-    } else {
-      scheduleStandbyRetry(electionState, standbyRetryMs, () => {
-        tryElection().catch(() => {
-        });
-      });
+      return;
+    }
+    standBy();
+  }
+  function reportElectionFailure(error) {
+    if (onElectionError === void 0) {
+      return;
+    }
+    try {
+      onElectionError(error);
+    } catch (_) {
+    }
+  }
+  async function runElection() {
+    try {
+      await standForElection();
+    } catch (error) {
+      reportElectionFailure(error);
+      standBy();
     }
   }
   const controller = {
@@ -1252,7 +1747,13 @@ function createController(config) {
     },
     async start() {
       stopped = false;
-      await tryElection();
+      clearStandbyTimer(electionState);
+      try {
+        await standForElection();
+      } catch (error) {
+        standBy();
+        throw error;
+      }
     },
     async stop() {
       stopped = true;
@@ -1476,7 +1977,7 @@ function createBootstrapState(indexName, partitionId, primaryNodeId) {
   };
 }
 
-// src/distribution/cluster/node-lifecycle/allocation-watcher.ts
+// src/distribution/cluster/node-lifecycle/allocation-watcher/state.ts
 function partitionKey(indexName, partitionId) {
   return `${indexName}:${partitionId}`;
 }
@@ -1486,40 +1987,137 @@ function createAllocationWatcherState() {
     debounceTimer: null,
     activeBootstraps: /* @__PURE__ */ new Map(),
     trackedPartitions: /* @__PURE__ */ new Map(),
+    pendingPartitions: /* @__PURE__ */ new Set(),
     pendingTables: /* @__PURE__ */ new Map(),
     restartWaiters: /* @__PURE__ */ new Map(),
+    retainedPartitions: /* @__PURE__ */ new Set(),
+    indexesSeededFromRecord: /* @__PURE__ */ new Set(),
     stopped: false
   };
 }
-async function startAllocationWatcher(state, config) {
-  const unwatchAllocation = await config.coordinator.watchAllocation((event) => {
-    if (state.stopped) {
-      return;
+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.pendingPartitions.clear();
+  state.retainedPartitions.clear();
+  state.indexesSeededFromRecord.clear();
+  state.pendingTables.clear();
+}
+
+// src/distribution/cluster/node-lifecycle/allocation-watcher/bootstrap-restart.ts
+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) {
+      state.activeBootstraps.delete(key);
     }
-    scheduleProcessAllocation(state, config, event.table);
+    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);
   });
-  state.unwatchAllocation = unwatchAllocation;
 }
-function scheduleProcessAllocation(state, config, table) {
-  state.pendingTables.set(table.indexName, table);
-  if (state.debounceTimer !== null) {
-    clearTimeout(state.debounceTimer);
+function waitBeforeBootstrapRestart(state, config) {
+  const delayMs = Math.min(config.bootstrapRetryMaxMs, config.bootstrapRetryBaseMs);
+  if (delayMs <= 0) {
+    return Promise.resolve();
   }
-  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);
+  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);
     }
-  }, config.allocationDebounceMs);
+    if (!state.stopped) {
+      void restartBootstrapWhileOutOfSync(state, config, indexName, partitionId);
+    }
+    return;
+  }
+  if (state.stopped || table === null) {
+    return;
+  }
+  const assignment = table.assignments.get(partitionId);
+  if (assignment === void 0 || assignment.primary === null || assignment.primary === nodeId) {
+    return;
+  }
+  if (!assignment.replicas.includes(nodeId) || assignment.inSyncSet.includes(nodeId)) {
+    return;
+  }
+  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/allocation-watcher/table.ts
 function processAllocationChange(state, config, table) {
   if (state.stopped) {
     return;
   }
   const nodeId = config.registration.nodeId;
   const currentKeys = /* @__PURE__ */ new Set();
+  seedRetainedFromRecord(state, config, table.indexName);
   for (const [partitionId, assignment] of table.assignments) {
     if (!isNodeAssigned(assignment, nodeId)) {
       continue;
@@ -1540,8 +2138,34 @@ function processAllocationChange(state, config, table) {
       primaryNodeId: assignment.primary,
       primaryTerm: assignment.primaryTerm
     });
+    if (servesPartition(assignment, nodeId)) {
+      state.pendingPartitions.delete(key);
+    } else {
+      state.pendingPartitions.add(key);
+    }
+    if (config.onHoldPartition !== void 0 && alreadyHoldsData(assignment, nodeId)) {
+      config.onHoldPartition(table.indexName, partitionId);
+    }
+  }
+  removeDroppedPartitions(state, config, table, currentKeys);
+  releaseSupersededCopies(state, config, table, currentKeys);
+}
+function processInitialAllocations(state, config, tables) {
+  for (const table of tables) {
+    processAllocationChange(state, config, table);
+  }
+}
+function servesPartition(assignment, nodeId) {
+  if (assignment.state === "INITIALISING" || assignment.state === "UNASSIGNED") {
+    return false;
+  }
+  return assignment.primary === nodeId || assignment.inSyncSet.includes(nodeId);
+}
+function alreadyHoldsData(assignment, nodeId) {
+  if (assignment.state !== "ACTIVE") {
+    return false;
   }
-  removeUnassignedPartitions(state, config, table.indexName, currentKeys);
+  return assignment.primary === nodeId || assignment.inSyncSet.includes(nodeId);
 }
 function isNodeAssigned(assignment, nodeId) {
   if (assignment.primary === nodeId) {
@@ -1574,6 +2198,10 @@ function handleExistingAssignment(state, config, existing, assignment, nodeId) {
     }
     return;
   }
+  if (promotedBackAtHigherTerm(existing, assignment, nodeId)) {
+    startBootstrap(state, config, existing.indexName, existing.partitionId, nodeId);
+    return;
+  }
   if (assignment.primary !== null && replicaNeedsResync(state, existing, assignment, nodeId)) {
     startBootstrap(state, config, existing.indexName, existing.partitionId, assignment.primary);
   }
@@ -1593,138 +2221,111 @@ function replicaNeedsResync(state, existing, assignment, nodeId) {
   }
   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);
+function promotedBackAtHigherTerm(existing, assignment, nodeId) {
+  return assignment.primary === nodeId && assignment.state === "INITIALISING" && assignment.primaryTerm > existing.primaryTerm;
+}
+function keepsCopyForRecovery(table, partitionId, nodeId) {
+  const assignment = table.assignments.get(partitionId);
+  if (assignment === void 0) {
+    return false;
   }
-  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) {
-      state.activeBootstraps.delete(key);
+  return holdsLastCopy(assignment, nodeId);
+}
+function seedRetainedFromRecord(state, config, indexName) {
+  if (config.retainedPartitionIds === void 0 || state.indexesSeededFromRecord.has(indexName)) {
+    return;
+  }
+  state.indexesSeededFromRecord.add(indexName);
+  for (const partitionId of config.retainedPartitionIds(indexName)) {
+    state.retainedPartitions.add(partitionKey(indexName, partitionId));
+  }
+}
+function retainedPartitionIdOf(key, indexName) {
+  if (!key.startsWith(`${indexName}:`)) {
+    return null;
+  }
+  const partitionId = Number(key.slice(indexName.length + 1));
+  return Number.isInteger(partitionId) ? partitionId : null;
+}
+function copyHasNoFurtherUse(table, partitionId, nodeId) {
+  if (table.assignments.size === 0) {
+    return true;
+  }
+  const assignment = table.assignments.get(partitionId);
+  if (assignment === void 0) {
+    return false;
+  }
+  return assignment.state === "ACTIVE" && assignment.primary !== null && assignment.primary !== nodeId;
+}
+function releaseSupersededCopies(state, config, table, currentKeys) {
+  const nodeId = config.registration.nodeId;
+  for (const key of [...state.retainedPartitions]) {
+    const partitionId = retainedPartitionIdOf(key, table.indexName);
+    if (partitionId === null) {
+      continue;
     }
-    if (!succeeded) {
-      state.trackedPartitions.delete(key);
-      void restartBootstrapWhileOutOfSync(state, config, indexName, partitionId);
+    if (currentKeys.has(key)) {
+      state.retainedPartitions.delete(key);
+      continue;
     }
-  }).catch(() => {
-    if (state.activeBootstraps.get(key) === bootstrapState) {
-      state.activeBootstraps.delete(key);
+    if (!copyHasNoFurtherUse(table, partitionId, nodeId)) {
+      continue;
     }
-    state.trackedPartitions.delete(key);
-    void restartBootstrapWhileOutOfSync(state, config, indexName, partitionId);
-  });
+    state.retainedPartitions.delete(key);
+    if (config.onRemovePartition !== void 0) {
+      config.onRemovePartition(table.indexName, partitionId);
+    }
+  }
 }
-function removeUnassignedPartitions(state, config, indexName, currentKeys) {
+function removeDroppedPartitions(state, config, table, currentKeys) {
   for (const [key, tracked] of state.trackedPartitions) {
-    if (tracked.indexName !== indexName) {
+    if (tracked.indexName !== table.indexName) {
       continue;
     }
     if (currentKeys.has(key)) {
       continue;
     }
     state.trackedPartitions.delete(key);
+    state.pendingPartitions.delete(key);
     const activeBootstrap = state.activeBootstraps.get(key);
     if (activeBootstrap !== void 0) {
       abortBootstrapState(activeBootstrap);
       state.activeBootstraps.delete(key);
     }
+    if (keepsCopyForRecovery(table, tracked.partitionId, config.registration.nodeId)) {
+      state.retainedPartitions.add(key);
+      continue;
+    }
+    state.retainedPartitions.delete(key);
     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);
+
+// src/distribution/cluster/node-lifecycle/allocation-watcher/index.ts
+async function startAllocationWatcher(state, config) {
+  const unwatchAllocation = await config.coordinator.watchAllocation((event) => {
+    if (state.stopped) {
+      return;
+    }
+    scheduleProcessAllocation(state, config, event.table);
   });
+  state.unwatchAllocation = unwatchAllocation;
 }
-async function restartBootstrapWhileOutOfSync(state, config, indexName, partitionId) {
-  if (state.stopped) {
-    return;
-  }
-  await waitBeforeBootstrapRestart(state, config);
-  if (state.stopped) {
-    return;
+function scheduleProcessAllocation(state, config, table) {
+  state.pendingTables.set(table.indexName, table);
+  if (state.debounceTimer !== null) {
+    clearTimeout(state.debounceTimer);
   }
-  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);
+  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);
     }
-    return;
-  }
-  if (state.stopped || table === null) {
-    return;
-  }
-  const assignment = table.assignments.get(partitionId);
-  if (assignment === void 0 || assignment.primary === null || assignment.primary === nodeId) {
-    return;
-  }
-  if (!assignment.replicas.includes(nodeId) || assignment.inSyncSet.includes(nodeId)) {
-    return;
-  }
-  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);
+  }, config.allocationDebounceMs);
 }
 
 // src/distribution/cluster/node-lifecycle/heartbeat.ts
@@ -1756,6 +2357,7 @@ async function stopRegistrationHeartbeat(state) {
 // src/distribution/cluster/node-lifecycle/join.ts
 async function joinCluster(config, watcherState, heartbeatState) {
   await config.coordinator.registerNode(config.registration);
+  config.onRegistered?.();
   startRegistrationHeartbeat(heartbeatState, config);
   const initialTables = await loadInitialAllocations(config);
   processInitialAllocations(watcherState, config, initialTables);
@@ -1763,7 +2365,8 @@ async function joinCluster(config, watcherState, heartbeatState) {
 }
 async function loadInitialAllocations(config) {
   const tables = [];
-  for (const indexName of config.knownIndexNames) {
+  const indexNames = /* @__PURE__ */ new Set([...config.knownIndexNames, ...await config.coordinator.listSchemas()]);
+  for (const indexName of indexNames) {
     const table = await config.coordinator.getAllocation(indexName);
     if (table !== null) {
       tables.push(table);
@@ -1787,6 +2390,7 @@ var DEFAULT_NODE_LIFECYCLE_CONFIG = {
 // src/distribution/cluster/node-lifecycle/index.ts
 function createDataNodeLifecycle(config) {
   let status = "stopped";
+  let registered = false;
   let watcherState = createAllocationWatcherState();
   const heartbeatState = createRegistrationHeartbeatState();
   let operationLock = Promise.resolve();
@@ -1813,6 +2417,12 @@ function createDataNodeLifecycle(config) {
     get nodeId() {
       return config.registration.nodeId;
     },
+    get registered() {
+      return registered;
+    },
+    get pendingPartitionCount() {
+      return watcherState.pendingPartitions.size;
+    },
     join() {
       return withLock(async () => {
         if (status === "active" || status === "joining") {
@@ -1831,10 +2441,21 @@ function createDataNodeLifecycle(config) {
         }
         status = "joining";
         try {
-          await joinCluster(config, watcherState, heartbeatState);
+          await joinCluster(
+            {
+              ...config,
+              onRegistered: () => {
+                registered = true;
+                config.onRegistered?.();
+              }
+            },
+            watcherState,
+            heartbeatState
+          );
           status = "active";
         } catch (error) {
           await stopRegistrationHeartbeat(heartbeatState);
+          registered = false;
           status = "stopped";
           throw error;
         }
@@ -1851,6 +2472,7 @@ function createDataNodeLifecycle(config) {
         try {
           await leaveCluster(config);
         } finally {
+          registered = false;
           status = "stopped";
           watcherState = createAllocationWatcherState();
         }
@@ -1869,6 +2491,7 @@ function createDataNodeLifecycle(config) {
           } catch (_) {
           }
         }
+        registered = false;
         status = "shutdown";
         watcherState = createAllocationWatcherState();
       });
@@ -1925,6 +2548,9 @@ async function nodeHasOtherPartitions(indexName, removedPartitionId, deps) {
     if (assignment.replicas.includes(deps.nodeId)) {
       return true;
     }
+    if (holdsLastCopy(assignment, deps.nodeId)) {
+      return true;
+    }
   }
   return false;
 }
@@ -3679,6 +4305,22 @@ async function executeBootstrapSync(state, entry, indexName, partitionId, primar
   return true;
 }
 
+// src/distribution/cluster-node/routable-allocation.ts
+async function routableAllocation(coordinator, indexName) {
+  const table = await coordinator.getAllocation(indexName);
+  if (table !== null && table.assignments.size > 0) {
+    return table;
+  }
+  if (await getIndexMetadata(coordinator, indexName) === null) {
+    return null;
+  }
+  throw new NarsilError(
+    ErrorCodes.QUERY_ROUTING_FAILED,
+    `The cluster owns index '${indexName}' and holds no allocation table for it yet, so this node cannot place a read or a write`,
+    { indexName }
+  );
+}
+
 // src/distribution/cluster-node/write-routing/assignment.ts
 function resolvePartitionId(docId, partitionCount) {
   return fnv1a(docId) % partitionCount;
@@ -3701,8 +4343,8 @@ function requireAssignedPrimary(assignment, 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) {
+  const table = await routableAllocation(deps.coordinator, indexName);
+  if (table === null) {
     if (requireLocalPrimary) {
       throw new NarsilError(
         ErrorCodes.QUERY_ROUTING_FAILED,
@@ -3829,7 +4471,7 @@ async function sendToController(payload, controllerNodeId, deps) {
   }
   return false;
 }
-function withTimeout(work, timeoutMs, fallback) {
+function withTimeout2(work, timeoutMs, fallback) {
   return new Promise((resolve) => {
     const timer = setTimeout(() => resolve(fallback), timeoutMs);
     timer.unref?.();
@@ -3884,9 +4526,9 @@ async function proposeAdmission(state, deps, indexName, partitionId, assignment,
       appliedSeqNo: cursor.appliedSeqNo,
       commitPoint: log.commitPoint
     };
-    const accepted = await withTimeout(sendToController(payload, controllerNodeId, deps), ADMISSION_TIMEOUT_MS, false);
+    const accepted = await withTimeout2(sendToController(payload, controllerNodeId, deps), ADMISSION_TIMEOUT_MS, false);
     if (accepted && cursor.syncEpoch !== proposedEpoch) {
-      await withTimeout(withdrawAdmission(payload, controllerNodeId, deps), ADMISSION_TIMEOUT_MS, void 0);
+      await withTimeout2(withdrawAdmission(payload, controllerNodeId, deps), ADMISSION_TIMEOUT_MS, void 0);
     }
   } finally {
     clearPendingAdmission(state, indexName, partitionId, replicaNodeId);
@@ -4094,6 +4736,114 @@ async function stopCatchUpPump(state) {
   }
 }
 
+// src/distribution/cluster-node/cluster-namespace.ts
+function readinessOf(deps) {
+  if (deps.isShutdown()) {
+    return "LEAVING";
+  }
+  const lifecycle = deps.lifecycle();
+  if (lifecycle.status === "leaving" || lifecycle.status === "shutdown") {
+    return "LEAVING";
+  }
+  if (!lifecycle.registered) {
+    return "STARTING";
+  }
+  if (lifecycle.status !== "active" || !deps.isServing() || lifecycle.pendingPartitionCount > 0) {
+    return "JOINING";
+  }
+  return "SERVING";
+}
+function createClusterNamespace(deps) {
+  return {
+    async getAllocation(indexName) {
+      return deps.trackOp(null, () => deps.coordinator.getAllocation(indexName));
+    },
+    getNodeInfo() {
+      return { nodeId: deps.nodeId, roles: [...deps.roles], status: deps.lifecycle().status };
+    },
+    isControllerActive() {
+      return deps.controller()?.isActive ?? false;
+    },
+    getReadiness() {
+      return readinessOf(deps);
+    },
+    async listNodes() {
+      return deps.trackOp(null, () => deps.coordinator.listNodes());
+    },
+    async getControllerNodeId() {
+      return deps.trackOp(null, () => deps.coordinator.getLeaseHolder(CONTROLLER_LEASE_KEY));
+    }
+  };
+}
+
+// src/distribution/cluster-node/error-forwarding.ts
+function createErrorForwarder(onError) {
+  return (error) => {
+    if (onError === void 0) {
+      return;
+    }
+    onError(error instanceof Error ? error : new Error(String(error)));
+  };
+}
+function createAllocationErrorForwarder(forwardOnError) {
+  return (indexName, error) => {
+    const code = error instanceof NarsilError ? error.code : ErrorCodes.ALLOCATION_FAILED;
+    const details = error instanceof NarsilError ? error.details : {};
+    const message = error instanceof Error ? error.message : String(error);
+    forwardOnError(
+      new NarsilError(code, `The controller could not allocate index '${indexName}': ${message}`, {
+        ...details,
+        indexName
+      })
+    );
+  };
+}
+
+// src/distribution/cluster-node/held-partitions.ts
+function createHeldPartitionRecord(core) {
+  const writesByIndex = /* @__PURE__ */ new Map();
+  const indexesBehindOnDisk = /* @__PURE__ */ new Set();
+  function queueWrite(indexName, next) {
+    const previous = writesByIndex.get(indexName) ?? Promise.resolve();
+    const write = previous.then(() => writeHeldPartitions(core, indexName, next, indexesBehindOnDisk));
+    writesByIndex.set(
+      indexName,
+      write.catch(() => void 0)
+    );
+    return write;
+  }
+  return {
+    record(indexName, partitionId) {
+      return queueWrite(indexName, (held) => held.includes(partitionId) ? null : [...held, partitionId]);
+    },
+    forget(indexName, partitionId) {
+      return queueWrite(indexName, (held) => held.includes(partitionId) ? held.filter((id) => id !== partitionId) : null);
+    },
+    held(indexName) {
+      return core.indexRegistry.get(indexName)?.heldPartitions ?? void 0;
+    }
+  };
+}
+async function writeHeldPartitions(core, indexName, next, indexesBehindOnDisk) {
+  const entry = core.indexRegistry.get(indexName);
+  if (entry === void 0) {
+    return;
+  }
+  const updated = next(entry.heldPartitions ?? []);
+  if (updated === null && !indexesBehindOnDisk.has(indexName)) {
+    return;
+  }
+  if (updated !== null) {
+    core.indexRegistry.set(indexName, { ...entry, heldPartitions: [...updated].sort((a, b) => a - b) });
+  }
+  if (core.durability === null) {
+    return;
+  }
+  indexesBehindOnDisk.add(indexName);
+  await core.durability.manager.persistMetadata(indexName);
+  indexesBehindOnDisk.delete(indexName);
+}
+
 // src/distribution/cluster-node/local-engine.ts
 async function createClusterLocalEngine(config) {
   const core = createEngineCore(config);
@@ -4105,10 +4855,15 @@ async function createClusterLocalEngine(config) {
   }
   await core.analysisRebuild.reviewStaleIndexes();
   const engine = createNarsilFromCore(core, config);
+  const heldPartitions = createHeldPartitionRecord(core);
   return Object.assign(engine, {
     createIndexWithUuid: (name, indexConfig, indexUuid) => createEngineIndex(core, config, name, indexConfig, indexUuid),
     indexUuidOf: (indexName) => core.indexRegistry.get(indexName)?.indexUuid,
     stampIndexUuid: (indexName, indexUuid) => stampIndexUuid(core, indexName, indexUuid),
+    highestPersistedSeqNoOf: (indexName, partitionId) => core.durability?.manager.highestPersistedSeqNo(indexName, partitionId) ?? 0,
+    heldPartitionsOf: (indexName) => heldPartitions.held(indexName),
+    recordHeldPartition: (indexName, partitionId) => heldPartitions.record(indexName, partitionId),
+    forgetHeldPartition: (indexName, partitionId) => heldPartitions.forget(indexName, partitionId),
     applyReplicationEntry: (entry) => applyReplicationEntry(core, entry),
     serializeReplicationPartition: (indexName, partitionId) => serializeReplicationPartition(core, indexName, partitionId),
     restoreReplicationPartition: (indexName, partitionId, bytes, schema, partitionCount) => restoreReplicationPartition(core, engine, indexName, partitionId, bytes, schema, partitionCount),
@@ -4950,6 +5705,28 @@ async function streamValidatedSnapshotRequest(message, sink, request, deps, opti
   }
   await acquireAndStream(message, sink, request, deps, options);
 }
+function describeLocalCopy(deps, indexName) {
+  const absent = { indexName, indexUuid: null, partitionIds: [] };
+  if (!deps.engine.listIndexes().some((index) => index.name === indexName)) {
+    return absent;
+  }
+  const indexUuid = deps.engine.indexUuidOf(indexName);
+  if (indexUuid === null || indexUuid === void 0) {
+    return absent;
+  }
+  const held = new Set(deps.engine.heldPartitionsOf(indexName) ?? []);
+  for (const partition of deps.engine.getPartitionStats(indexName)) {
+    if (partition.documentCount > 0) {
+      held.add(partition.partitionId);
+    }
+  }
+  return { indexName, indexUuid, partitionIds: [...held].sort((left, right) => left - right) };
+}
+async function handlePartitionStores(message, respond, deps) {
+  const payload = validatePartitionStoresPayload(decode(message.payload));
+  const result = payload === null ? { indexName: "", indexUuid: null, partitionIds: [] } : describeLocalCopy(deps, payload.indexName);
+  await respond(createPartitionStoresResultMessage(result, deps.nodeId, message.requestId));
+}
 
 // src/distribution/query/validators/common.ts
 var MAX_PARTITION_IDS = MAX_PARTITION_COUNT;
@@ -6293,7 +7070,8 @@ function distributedResultToLocal(result, documents = /* @__PURE__ */ new Map())
     count: result.totalHits,
     elapsed: 0,
     cursor: result.cursor ?? void 0,
-    facets: result.facets !== null ? convertWireFacetsToLocal(result.facets, result.facetErrorBounds) : void 0
+    facets: result.facets !== null ? convertWireFacetsToLocal(result.facets, result.facetErrorBounds) : void 0,
+    coverage: result.coverage
   };
 }
 function convertLocalSortToWire(sort) {
@@ -6601,6 +7379,13 @@ async function handleSyncRequestMessage(message, respond, deps) {
       }
     );
   }
+  if (!deps.engine.listIndexes().some((index) => index.name === request.indexName)) {
+    throw new NarsilError(
+      ErrorCodes.SNAPSHOT_SYNC_INDEX_NOT_FOUND,
+      `Node '${deps.nodeId}' holds no copy of index '${request.indexName}' yet, so it cannot serve a sync for partition ${request.partitionId}`,
+      { indexName: request.indexName, partitionId: request.partitionId, primaryNodeId: deps.nodeId }
+    );
+  }
   if (message.sourceId !== deps.nodeId) {
     recordReplicaPosition(
       deps.writeDeps.catchUp,
@@ -6661,6 +7446,55 @@ async function sendSyncEntriesResponse(message, respond, deps, entries) {
   });
 }
 
+// src/distribution/cluster-node/allocation-wait.ts
+var DEFAULT_CREATE_INDEX_WAIT_MS = 3e4;
+function everyPartitionActive(table, partitionCount) {
+  if (table === null || table.assignments.size < partitionCount) {
+    return false;
+  }
+  for (const assignment of table.assignments.values()) {
+    if (assignment.state !== "ACTIVE") {
+      return false;
+    }
+  }
+  return true;
+}
+async function allocationPossible(coordinator) {
+  const nodes = await coordinator.listNodes();
+  return nodes.some((node) => node.roles.includes("controller")) && nodes.some((node) => node.roles.includes("data"));
+}
+async function waitForServingAllocation(coordinator, indexName, partitionCount, timeoutMs) {
+  if (timeoutMs <= 0) {
+    return;
+  }
+  let settle = () => void 0;
+  const outcome = new Promise((resolve) => {
+    settle = resolve;
+  });
+  const deadline = setTimeout(settle, timeoutMs);
+  deadline.unref?.();
+  let unwatch = () => void 0;
+  try {
+    unwatch = await coordinator.watchAllocation((event) => {
+      if (event.indexName === indexName && everyPartitionActive(event.table, partitionCount)) {
+        settle();
+      }
+    });
+    if (everyPartitionActive(await coordinator.getAllocation(indexName), partitionCount)) {
+      return;
+    }
+    if (!await allocationPossible(coordinator)) {
+      return;
+    }
+    await outcome;
+  } catch (_) {
+    return;
+  } finally {
+    clearTimeout(deadline);
+    unwatch();
+  }
+}
+
 // src/distribution/cluster-node/types/defaults.ts
 var DEFAULT_PARTITION_COUNT = 5;
 var DEFAULT_REPLICATION_FACTOR = 1;
@@ -7540,8 +8374,8 @@ function collectGroupFailure(failed, docIds, err, indexName, fallbackCode) {
   }
 }
 async function routeInsertBatch(indexName, documents, deps, options) {
-  const table = await deps.coordinator.getAllocation(indexName);
-  if (table === null || table.assignments.size === 0) {
+  const table = await routableAllocation(deps.coordinator, indexName);
+  if (table === null) {
     return deps.engine.insertBatch(indexName, documents, options);
   }
   const withIds = documents.map((doc) => ({
@@ -7579,8 +8413,8 @@ async function routeInsertBatch(indexName, documents, deps, options) {
   return { succeeded, failed };
 }
 async function routeRemoveBatch(indexName, docIds, deps) {
-  const table = await deps.coordinator.getAllocation(indexName);
-  if (table === null || table.assignments.size === 0) {
+  const table = await routableAllocation(deps.coordinator, indexName);
+  if (table === null) {
     return deps.engine.removeBatch(indexName, docIds);
   }
   const routed = routeBatchItems(table, indexName, docIds, (docId) => docId, deps.nodeId);
@@ -7608,8 +8442,8 @@ async function routeRemoveBatch(indexName, docIds, deps) {
   return { succeeded, failed };
 }
 async function routeUpdateBatch(indexName, updates, deps) {
-  const table = await deps.coordinator.getAllocation(indexName);
-  if (table === null || table.assignments.size === 0) {
+  const table = await routableAllocation(deps.coordinator, indexName);
+  if (table === null) {
     return deps.engine.updateBatch(indexName, updates);
   }
   const routed = routeBatchItems(table, indexName, updates, (update) => update.docId, deps.nodeId);
@@ -7710,6 +8544,12 @@ async function routeCreateIndex(name, config, options, coordinator, engine) {
     }
     throw createErr;
   }
+  await waitForServingAllocation(
+    coordinator,
+    name,
+    partitionCount,
+    options?.waitForServingMs ?? DEFAULT_CREATE_INDEX_WAIT_MS
+  );
 }
 async function withdrawPartialIndex(name, coordinator, engine) {
   try {
@@ -7987,6 +8827,9 @@ function createDataNodeHandler(deps) {
         case QueryMessageTypes.PREFLIGHT:
           await handlePreflight(message, respond, deps);
           return;
+        case ClusterMessageTypes.PARTITION_STORES:
+          await handlePartitionStores(message, respond, deps);
+          return;
         default:
           return;
       }
@@ -8242,22 +9085,32 @@ async function fanOutSearch(indexName, params, globalStats, facetShardSize, node
   }
   return Promise.all(promises);
 }
-function buildCoverage(totalPartitions, unavailableCount, outcomes) {
+var OUTCOME_SEVERITY = { success: 0, timeout: 1, failed: 2 };
+function buildCoverage(totalPartitions, unavailablePartitions, ...outcomeSets) {
+  const worstByPartition = /* @__PURE__ */ new Map();
+  for (const partitionId of unavailablePartitions) {
+    worstByPartition.set(partitionId, "failed");
+  }
+  for (const outcomes of outcomeSets) {
+    for (const outcome of outcomes) {
+      for (const partitionId of outcome.partitionIds) {
+        const worstSoFar = worstByPartition.get(partitionId);
+        if (worstSoFar === void 0 || OUTCOME_SEVERITY[outcome.status] > OUTCOME_SEVERITY[worstSoFar]) {
+          worstByPartition.set(partitionId, outcome.status);
+        }
+      }
+    }
+  }
   let queriedPartitions = 0;
   let timedOutPartitions = 0;
-  let failedPartitions = unavailableCount;
-  for (const outcome of outcomes) {
-    const partitionCount = outcome.partitionIds.length;
-    switch (outcome.status) {
-      case "success":
-        queriedPartitions += partitionCount;
-        break;
-      case "timeout":
-        timedOutPartitions += partitionCount;
-        break;
-      case "failed":
-        failedPartitions += partitionCount;
-        break;
+  let failedPartitions = 0;
+  for (const status of worstByPartition.values()) {
+    if (status === "success") {
+      queriedPartitions += 1;
+    } else if (status === "timeout") {
+      timedOutPartitions += 1;
+    } else {
+      failedPartitions += 1;
     }
   }
   return {
@@ -8275,7 +9128,7 @@ async function sendWithTimeout(transport, targets, message, timeout, validate) {
       timerId.unref();
     }
   });
-  const sendPromise = sendToFirstReachableTarget(transport, targets, message).then((response) => {
+  const sendPromise = sendToFirstReachableTarget2(transport, targets, message).then((response) => {
     const decoded = decode(response.payload);
     return validate(decoded);
   });
@@ -8294,7 +9147,7 @@ async function resolveTargets(nodeId, deps) {
   const targets = await deps.resolveNodeTargets(nodeId);
   return targets.length > 0 ? targets : [nodeId];
 }
-async function sendToFirstReachableTarget(transport, targets, message) {
+async function sendToFirstReachableTarget2(transport, targets, message) {
   let lastError;
   for (const target of targets) {
     try {
@@ -8594,9 +9447,11 @@ async function distributedQuery(indexName, params, deps, config, selector) {
   const routing = selectReplicasForQuery(allocationTable, randomSelector);
   const totalPartitions = allocationTable.assignments.size;
   if (routing.unavailablePartitions.length > 0 && !resolvedConfig.allowPartialResults) {
-    throw new NarsilError(ErrorCodes.QUERY_NO_ACTIVE_REPLICA, "No active replica for one or more partitions", {
-      unavailablePartitions: routing.unavailablePartitions
-    });
+    throw new NarsilError(
+      ErrorCodes.QUERY_PARTIAL_FAILURE,
+      "No active replica serves one or more partitions, and this node refuses partial results",
+      { unavailablePartitions: routing.unavailablePartitions }
+    );
   }
   const isHybrid = params.hybrid !== null && params.term !== null && params.vector !== null;
   if (isHybrid && params.searchAfter !== null) {
@@ -8658,7 +9513,7 @@ async function executeSingleFanOut(indexName, params, limit, offset, facetShardS
   if (sortFields !== null) {
     failOutcomesMissingSortValues(outcomes);
   }
-  const coverage = buildCoverage(totalPartitions, routing.unavailablePartitions.length, outcomes);
+  const coverage = buildCoverage(totalPartitions, routing.unavailablePartitions, outcomes);
   if (!config.allowPartialResults) {
     const failedCount = coverage.timedOutPartitions + coverage.failedPartitions;
     if (failedCount > 0) {
@@ -8732,9 +9587,7 @@ async function executeHybridQuery(indexName, params, limit, offset, facetShardSi
     fanOutSearch(indexName, textParams, textGlobalStats, facetShardSize, routing.nodeToPartitions, deps, config),
     fanOutSearch(indexName, vectorParams, null, null, routing.nodeToPartitions, deps, config)
   ]);
-  const textCoverage = buildCoverage(totalPartitions, routing.unavailablePartitions.length, textOutcomes);
-  const vectorCoverage = buildCoverage(totalPartitions, routing.unavailablePartitions.length, vectorOutcomes);
-  const coverage = worstCaseCoverage(textCoverage, vectorCoverage);
+  const coverage = buildCoverage(totalPartitions, routing.unavailablePartitions, textOutcomes, vectorOutcomes);
   if (!config.allowPartialResults) {
     const failedCount = coverage.timedOutPartitions + coverage.failedPartitions;
     if (failedCount > 0) {
@@ -8796,29 +9649,6 @@ async function executeHybridQuery(indexName, params, limit, offset, facetShardSi
     coverage
   };
 }
-function worstCaseCoverage(a, b) {
-  const failed = Math.max(a.failedPartitions, b.failedPartitions);
-  const timedOut = Math.max(a.timedOutPartitions, b.timedOutPartitions);
-  const queried = Math.max(0, a.totalPartitions - failed - timedOut);
-  return {
-    totalPartitions: a.totalPartitions,
-    queriedPartitions: queried,
-    timedOutPartitions: timedOut,
-    failedPartitions: failed
-  };
-}
-async function activeAllocation(deps, indexName) {
-  const allocation = await deps.config.coordinator.getAllocation(indexName);
-  if (allocation === null || allocation.assignments.size === 0) {
-    return null;
-  }
-  for (const [, assignment] of allocation.assignments) {
-    if (assignment.state === "ACTIVE") {
-      return allocation;
-    }
-  }
-  return null;
-}
 function strictScatterGroups(allocation, indexName) {
   const routing = selectReplicasForQuery(allocation, randomSelector);
   if (routing.unavailablePartitions.length > 0) {
@@ -8830,8 +9660,30 @@ function strictScatterGroups(allocation, indexName) {
   }
   return Array.from(routing.nodeToPartitions.entries(), ([nodeId, partitionIds]) => ({ nodeId, partitionIds }));
 }
+var READ_FAILURE_BY_TRANSPORT_CODE = {
+  [TransportErrorCodes.CONNECT_FAILED]: ErrorCodes.QUERY_NO_ACTIVE_REPLICA,
+  [TransportErrorCodes.PEER_UNAVAILABLE]: ErrorCodes.QUERY_NO_ACTIVE_REPLICA,
+  [TransportErrorCodes.TIMEOUT]: ErrorCodes.QUERY_NODE_TIMEOUT,
+  [TransportErrorCodes.MESSAGE_TOO_LARGE]: ErrorCodes.QUERY_ROUTING_FAILED,
+  [TransportErrorCodes.DECODE_FAILED]: ErrorCodes.QUERY_ROUTING_FAILED
+};
+function readFailure(error, targetNodeId, indexName) {
+  if (error instanceof NarsilError) {
+    return error;
+  }
+  if (error instanceof TransportError) {
+    return new NarsilError(
+      READ_FAILURE_BY_TRANSPORT_CODE[error.code],
+      `Node '${targetNodeId}' did not answer a read request for index '${indexName}'`,
+      { indexName, targetNodeId, transportCode: error.code }
+    );
+  }
+  return error;
+}
 async function sendReadRequest(deps, targetNodeId, message, indexName, validate) {
-  const response = await sendToNode2(deps.config, targetNodeId, message);
+  const response = await sendToNode2(deps.config, targetNodeId, message).catch((error) => {
+    throw readFailure(error, targetNodeId, indexName);
+  });
   const decoded = decode(response.payload);
   if (response.type.endsWith(".error") || response.type === "error" || decoded.error === true) {
     throw new NarsilError(
@@ -8890,7 +9742,7 @@ async function gatherPartitionCounts(deps, indexName, allocation) {
   return { countsByPartition, language };
 }
 async function countCluster(deps, indexName) {
-  const allocation = await activeAllocation(deps, indexName);
+  const allocation = await routableAllocation(deps.config.coordinator, indexName);
   if (allocation === null) {
     return deps.engine.countDocuments(indexName);
   }
@@ -8902,7 +9754,7 @@ async function countCluster(deps, indexName) {
   return total;
 }
 async function statsCluster(deps, indexName) {
-  const allocation = await activeAllocation(deps, indexName);
+  const allocation = await routableAllocation(deps.config.coordinator, indexName);
   if (allocation === null) {
     return deps.engine.getStats(indexName);
   }
@@ -8928,7 +9780,7 @@ async function statsCluster(deps, indexName) {
   };
 }
 async function partitionStatsCluster(deps, indexName) {
-  const allocation = await activeAllocation(deps, indexName);
+  const allocation = await routableAllocation(deps.config.coordinator, indexName);
   if (allocation === null) {
     return deps.engine.getPartitionStats(indexName);
   }
@@ -8982,7 +9834,7 @@ async function gatherLocalPage(deps, indexName, payload, partitionIds, sortField
   return { entries, total: result.total, hasMore: result.cursor !== null };
 }
 async function listCluster(deps, indexName, params) {
-  const allocation = await activeAllocation(deps, indexName);
+  const allocation = await routableAllocation(deps.config.coordinator, indexName);
   if (allocation === null) {
     return deps.engine.listDocuments(indexName, params);
   }
@@ -9069,7 +9921,7 @@ function suggestNodeLimit(clientLimit) {
   return Math.min(oversampled, MAX_SUGGEST_SCATTER_LIMIT);
 }
 async function suggestCluster(deps, indexName, params) {
-  const allocation = await activeAllocation(deps, indexName);
+  const allocation = await routableAllocation(deps.config.coordinator, indexName);
   if (allocation === null) {
     return deps.engine.suggest(indexName, params);
   }
@@ -9113,7 +9965,7 @@ async function suggestCluster(deps, indexName, params) {
   return result;
 }
 async function preflightCluster(deps, indexName, params) {
-  const allocation = await activeAllocation(deps, indexName);
+  const allocation = await routableAllocation(deps.config.coordinator, indexName);
   if (allocation === null) {
     return deps.engine.preflight(indexName, params);
   }
@@ -9148,14 +10000,27 @@ async function preflightCluster(deps, indexName, params) {
 
 // src/distribution/cluster-node/reads/index.ts
 async function readClusterDocuments(deps, indexName, docIds) {
-  const allocation = await activeAllocation(deps, indexName);
+  const allocation = await routableAllocation(deps.config.coordinator, indexName);
   if (allocation === null) {
     return deps.engine.getMultiple(indexName, docIds);
   }
   return readDistributedDocuments(deps.config, deps.nodeId, deps.engine, indexName, docIds, allocation);
 }
+function routingConfig(query) {
+  if (query === void 0) {
+    return void 0;
+  }
+  const config = {};
+  if (query.allowPartialResults !== void 0) {
+    config.allowPartialResults = query.allowPartialResults;
+  }
+  if (query.partitionTimeout !== void 0) {
+    config.partitionTimeout = query.partitionTimeout;
+  }
+  return config;
+}
 async function queryCluster(deps, indexName, params) {
-  const allocation = await activeAllocation(deps, indexName);
+  const allocation = await routableAllocation(deps.config.coordinator, indexName);
   if (allocation === null) {
     return deps.engine.query(indexName, params);
   }
@@ -9166,7 +10031,7 @@ async function queryCluster(deps, indexName, params) {
     getAllocation: (idx) => deps.config.coordinator.getAllocation(idx),
     resolveNodeTargets: deps.resolveNodeTargets
   };
-  const distributed = await distributedQuery(indexName, wireParams, queryDeps);
+  const distributed = await distributedQuery(indexName, wireParams, queryDeps, routingConfig(deps.config.query));
   const documents = await fetchDistributedDocuments(
     deps.config,
     deps.nodeId,
@@ -9182,7 +10047,7 @@ async function queryCluster(deps, indexName, params) {
 // src/distribution/cluster-node/clear.ts
 var CLEAR_PAGE_SIZE = 1e3;
 async function clearCluster(readDeps, writeDeps, indexName) {
-  const allocation = await activeAllocation(readDeps, indexName);
+  const allocation = await routableAllocation(readDeps.config.coordinator, indexName);
   if (allocation === null) {
     return readDeps.engine.clear(indexName);
   }
@@ -9292,6 +10157,53 @@ function createClusterNodeOperations(deps) {
   };
 }
 
+// src/distribution/cluster-node/primary-partition.ts
+async function preparePrimaryPartition(indexName, partitionId, deps) {
+  const schema = await deps.coordinator.getSchema(indexName);
+  if (schema === null) {
+    return false;
+  }
+  const allocation = await deps.coordinator.getAllocation(indexName);
+  if (allocation === null || allocation.assignments.size === 0) {
+    return false;
+  }
+  const existing = deps.engine.listIndexes().find((index) => index.name === indexName);
+  if (existing === void 0) {
+    try {
+      await deps.engine.createIndex(indexName, {
+        schema,
+        partitions: { maxPartitions: allocation.assignments.size }
+      });
+    } catch (error) {
+      if (!(error instanceof NarsilError) || error.code !== ErrorCodes.INDEX_ALREADY_EXISTS) {
+        deps.onError(error);
+        return false;
+      }
+    }
+  } else {
+    const schemaError = validateRestoredSchema(deps.engine, indexName, deps.nodeId, schema);
+    if (schemaError !== null) {
+      deps.onError(schemaError);
+      return false;
+    }
+  }
+  resumeNumberingAboveOwnCopy(indexName, partitionId, allocation.assignments.get(partitionId), deps);
+  return true;
+}
+function resumeNumberingAboveOwnCopy(indexName, partitionId, assignment, deps) {
+  if (assignment === void 0) {
+    return;
+  }
+  if (deps.replicationLogPosition(indexName, partitionId) > 0) {
+    return;
+  }
+  const floor = Math.max(deps.engine.highestPersistedSeqNoOf(indexName, partitionId), assignment.commitPoint);
+  if (floor <= 0) {
+    return;
+  }
+  deps.seedReplicationLog(indexName, partitionId, floor + 1, assignment.primaryTerm);
+}
+
 // src/distribution/replication/types.ts
 var DEFAULT_LOG_RETENTION_BYTES = 268435456;
 
@@ -9527,14 +10439,29 @@ 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
 ]);
-function createMultiplexedControllerTransport(baseTransport) {
+function refuseMessage(nodeId, message, respond, code, text) {
+  return respond({
+    type: `${message.type}.error`,
+    sourceId: nodeId,
+    requestId: message.requestId,
+    payload: encode({ error: true, code, message: text })
+  });
+}
+function createNotReadyHandler(nodeId) {
+  return (message, respond) => refuseMessage(
+    nodeId,
+    message,
+    respond,
+    ErrorCodes.NODE_NOT_READY,
+    `Node '${nodeId}' has yet to finish joining the cluster, so it serves nothing`
+  );
+}
+function createMultiplexedControllerTransport(baseTransport, nodeId) {
   let controllerHandler = null;
   const transport = {
     send(target, message) {
@@ -9561,9 +10488,17 @@ function createMultiplexedControllerTransport(baseTransport) {
     createHandler(dataHandler) {
       return async (message, respond) => {
         if (CONTROLLER_MESSAGE_TYPES.has(message.type)) {
-          if (controllerHandler !== null) {
-            await controllerHandler(message, createSingleResponseRespond(respond));
+          if (controllerHandler === null) {
+            await refuseMessage(
+              nodeId,
+              message,
+              respond,
+              ErrorCodes.NODE_NOT_CONTROLLER,
+              `Node '${nodeId}' holds no controller lease, so it answers no controller message`
+            );
+            return;
           }
+          await controllerHandler(message, createSingleResponseRespond(respond));
           return;
         }
         await dataHandler(message, respond);
@@ -9584,6 +10519,7 @@ function createSingleResponseRespond(respond) {
 
 // src/distribution/cluster-node/validate-config.ts
 var MAX_WAIT_FOR_ACTIVE_REPLICAS = 255;
+var MIN_CONTROLLER_LEASE_TTL_MS = 1e3;
 function validateClusterNodeConfig(config) {
   if (config.address.length === 0) {
     throw new NarsilError(ErrorCodes.CONFIG_INVALID, "ClusterNodeConfig.address must not be empty");
@@ -9627,6 +10563,42 @@ function validateClusterNodeConfig(config) {
       );
     }
   }
+  if (config.query !== void 0) {
+    const { allowPartialResults, partitionTimeout } = config.query;
+    if (allowPartialResults !== void 0 && typeof allowPartialResults !== "boolean") {
+      throw new NarsilError(
+        ErrorCodes.CONFIG_INVALID,
+        "ClusterNodeConfig.query.allowPartialResults must be a boolean",
+        {
+          allowPartialResults
+        }
+      );
+    }
+    if (partitionTimeout !== void 0 && (!Number.isInteger(partitionTimeout) || partitionTimeout <= 0)) {
+      throw new NarsilError(
+        ErrorCodes.CONFIG_INVALID,
+        "ClusterNodeConfig.query.partitionTimeout must be a positive integer",
+        { partitionTimeout }
+      );
+    }
+  }
+  if (config.controller !== void 0) {
+    const { leaseTtlMs, standbyRetryMs } = config.controller;
+    if (leaseTtlMs !== void 0 && (!Number.isInteger(leaseTtlMs) || leaseTtlMs < MIN_CONTROLLER_LEASE_TTL_MS)) {
+      throw new NarsilError(
+        ErrorCodes.CONFIG_INVALID,
+        `ClusterNodeConfig.controller.leaseTtlMs must be an integer of at least ${MIN_CONTROLLER_LEASE_TTL_MS}`,
+        { leaseTtlMs }
+      );
+    }
+    if (standbyRetryMs !== void 0 && (!Number.isInteger(standbyRetryMs) || standbyRetryMs <= 0)) {
+      throw new NarsilError(
+        ErrorCodes.CONFIG_INVALID,
+        "ClusterNodeConfig.controller.standbyRetryMs must be a positive integer",
+        { standbyRetryMs }
+      );
+    }
+  }
 }
 
 // src/distribution/cluster-node/index.ts
@@ -9652,13 +10624,8 @@ async function createClusterNode(config) {
   async function resolveNodeTargets3(targetNodeId) {
     return resolveNodeTargets2(config, targetNodeId);
   }
-  const forwardOnError = (error) => {
-    if (config.onError === void 0) {
-      return;
-    }
-    const wrapped = error instanceof Error ? error : new Error(String(error));
-    config.onError(wrapped);
-  };
+  const forwardOnError = createErrorForwarder(config.onError);
+  const forwardAllocationError = createAllocationErrorForwarder(forwardOnError);
   const registration = {
     nodeId,
     address: config.address,
@@ -9669,7 +10636,7 @@ async function createClusterNode(config) {
   };
   const hasDataRole = roles.includes("data");
   const hasControllerRole = roles.includes("controller");
-  const controllerTransport = hasDataRole && hasControllerRole ? createMultiplexedControllerTransport(config.transport) : null;
+  const controllerTransport = hasDataRole ? createMultiplexedControllerTransport(config.transport, nodeId) : null;
   const writeDeps = {
     nodeId,
     coordinator: config.coordinator,
@@ -9683,9 +10650,16 @@ async function createClusterNode(config) {
     waitForActiveReplicas: config.replication?.waitForActiveReplicas
   };
   const orphanedIndexes = /* @__PURE__ */ new Set();
-  let lifecycle = null;
+  const heldPartitionWrites = /* @__PURE__ */ new Set();
+  function trackHeldPartitionWrite(write) {
+    const settled = write.catch(forwardOnError);
+    heldPartitionWrites.add(settled);
+    void settled.finally(() => heldPartitionWrites.delete(settled));
+  }
   let controller = null;
   let unregisterHandler = null;
+  let unregisterNotReadyHandler = null;
+  let serving = false;
   let isShutdown = false;
   let activeOps = 0;
   let drainResolve = null;
@@ -9701,76 +10675,59 @@ async function createClusterNode(config) {
     restoreReplicationPartition: engine.restoreReplicationPartition,
     onError: forwardOnError
   };
+  const primaryPartitionDeps = {
+    engine,
+    coordinator: config.coordinator,
+    nodeId,
+    seedReplicationLog: seedReplicationLog2,
+    replicationLogPosition: (indexName, partitionId) => getReplicationLog2(indexName, partitionId).newestSeqNo ?? 0,
+    onError: forwardOnError
+  };
   async function bootstrapPartition2(indexName, partitionId, primaryNodeId) {
-    const succeeded = primaryNodeId === nodeId ? await preparePrimaryPartition(indexName) : await runBootstrapSync(bootstrapSyncState, indexName, partitionId, primaryNodeId, bootstrapSyncDeps);
+    const succeeded = primaryNodeId === nodeId ? await preparePrimaryPartition(indexName, partitionId, primaryPartitionDeps) : await runBootstrapSync(bootstrapSyncState, indexName, partitionId, primaryNodeId, bootstrapSyncDeps);
     if (succeeded) {
       await adoptClusterIdentity(engine, config.coordinator, indexName);
+      await engine.recordHeldPartition(indexName, partitionId);
     }
     return succeeded;
   }
-  async function preparePrimaryPartition(indexName) {
-    const schema = await config.coordinator.getSchema(indexName);
-    if (schema === null) {
-      return false;
-    }
-    const allocation = await config.coordinator.getAllocation(indexName);
-    if (allocation === null || allocation.assignments.size === 0) {
-      return false;
-    }
-    const existing = engine.listIndexes().find((index) => index.name === indexName);
-    if (existing !== void 0) {
-      const schemaError = validateRestoredSchema(engine, indexName, nodeId, schema);
-      if (schemaError !== null) {
-        forwardOnError(schemaError);
-        return false;
-      }
-      return true;
-    }
-    try {
-      await engine.createIndex(indexName, {
-        schema,
-        partitions: { maxPartitions: allocation.assignments.size }
+  const lifecycle = createDataNodeLifecycle({
+    registration,
+    coordinator: config.coordinator,
+    transport: config.transport,
+    knownIndexNames: [],
+    bootstrapRetryBaseMs: DEFAULT_NODE_LIFECYCLE_CONFIG.bootstrapRetryBaseMs,
+    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,
+    onHoldPartition: (indexName, partitionId) => {
+      trackHeldPartitionWrite(engine.recordHeldPartition(indexName, partitionId));
+    },
+    retainedPartitionIds: (indexName) => engine.heldPartitionsOf(indexName) ?? [],
+    onRemovePartition: (indexName, partitionId) => {
+      clearBootstrapSyncIndex(bootstrapSyncState, indexName, partitionId);
+      replicationLogs.delete(replicationLogKey2(indexName, partitionId));
+      trackHeldPartitionWrite(engine.forgetHeldPartition(indexName, partitionId));
+      void cleanupRemovedPartition(indexName, partitionId, {
+        engine,
+        coordinator: config.coordinator,
+        nodeId,
+        onError: forwardOnError
       });
-    } catch (error) {
-      if (!(error instanceof NarsilError) || error.code !== ErrorCodes.INDEX_ALREADY_EXISTS) {
-        forwardOnError(error);
-        return false;
-      }
     }
-    return true;
-  }
-  if (hasDataRole) {
-    lifecycle = createDataNodeLifecycle({
-      registration,
-      coordinator: config.coordinator,
-      transport: config.transport,
-      knownIndexNames: [],
-      bootstrapRetryBaseMs: DEFAULT_NODE_LIFECYCLE_CONFIG.bootstrapRetryBaseMs,
-      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);
-        replicationLogs.delete(replicationLogKey2(indexName, partitionId));
-        void cleanupRemovedPartition(indexName, partitionId, {
-          engine,
-          coordinator: config.coordinator,
-          nodeId,
-          onError: forwardOnError
-        });
-      }
-    });
-  }
+  });
   if (hasControllerRole) {
     controller = createController({
       nodeId,
       coordinator: config.coordinator,
       transport: controllerTransport?.transport ?? config.transport,
-      leaseTtlMs: DEFAULT_CONTROLLER_CONFIG.leaseTtlMs,
-      standbyRetryMs: DEFAULT_CONTROLLER_CONFIG.standbyRetryMs,
-      knownIndexNames: []
+      leaseTtlMs: config.controller?.leaseTtlMs ?? DEFAULT_CONTROLLER_CONFIG.leaseTtlMs,
+      standbyRetryMs: config.controller?.standbyRetryMs ?? DEFAULT_CONTROLLER_CONFIG.standbyRetryMs,
+      knownIndexNames: [],
+      onError: forwardAllocationError,
+      onElectionError: forwardOnError
     });
   }
   function guardShutdown() {
@@ -9795,21 +10752,16 @@ async function createClusterNode(config) {
     }
   }
   const readDeps = { config, nodeId, engine, resolveNodeTargets: resolveNodeTargets3 };
-  const cluster = {
-    async getAllocation(indexName) {
-      return trackOp(null, () => config.coordinator.getAllocation(indexName));
-    },
-    getNodeInfo() {
-      const status = lifecycle !== null ? lifecycle.status : isShutdown ? "shutdown" : "stopped";
-      return { nodeId, roles: [...roles], status };
-    },
-    isControllerActive() {
-      if (controller === null) {
-        return false;
-      }
-      return controller.isActive;
-    }
-  };
+  const cluster = createClusterNamespace({
+    nodeId,
+    roles,
+    coordinator: config.coordinator,
+    lifecycle: () => lifecycle,
+    controller: () => controller,
+    isShutdown: () => isShutdown,
+    isServing: () => serving,
+    trackOp
+  });
   const node = {
     get nodeId() {
       return nodeId;
@@ -9843,9 +10795,10 @@ async function createClusterNode(config) {
           orphanedIndexes.add(indexName);
         }
       }
-      if (lifecycle !== null) {
-        await lifecycle.join();
+      if (hasDataRole) {
+        unregisterNotReadyHandler = await config.transport.listen(createNotReadyHandler(nodeId));
       }
+      await lifecycle.join();
       if (controller !== null) {
         await controller.start();
       }
@@ -9863,6 +10816,7 @@ async function createClusterNode(config) {
         unregisterHandler = await config.transport.listen(listener);
         startCatchUpPump(writeDeps.catchUp, writeDeps);
       }
+      serving = true;
     },
     async shutdown() {
       await stopCatchUpPump(writeDeps.catchUp);
@@ -9870,6 +10824,7 @@ async function createClusterNode(config) {
         return;
       }
       isShutdown = true;
+      serving = false;
       if (activeOps > 0) {
         await new Promise((resolve) => {
           drainResolve = resolve;
@@ -9879,12 +10834,15 @@ async function createClusterNode(config) {
         unregisterHandler();
         unregisterHandler = null;
       }
-      if (lifecycle !== null) {
-        await lifecycle.shutdown();
+      if (unregisterNotReadyHandler !== null) {
+        unregisterNotReadyHandler();
+        unregisterNotReadyHandler = null;
       }
+      await lifecycle.shutdown();
       if (controller !== null) {
         await controller.shutdown();
       }
+      await Promise.all([...heldPartitionWrites]);
       await engine.shutdown();
     }
   };