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

package/README.md

@@ -79,7 +79,7 @@ const results = await narsil.query('products', {
 })
 ```
 
-Every hit holds the document, its id, and its BM25 score. `results.count` reports how many documents matched in total, and `results.elapsed` reports the query time in milliseconds.
+Every hit holds the document, its id, and its BM25 score. `results.count` reports how many documents matched in total, `results.elapsed` reports the query time in milliseconds, and `results.coverage` reports how many partitions the search read, which is how you spot a cluster that answered from part of its data.
 
 ## Features
 
@@ -129,7 +129,7 @@ The [specification](../spec/) defines the `.nrsl` format, the analysis pipeline,
 
 ## Distribution
 
-`@delali/narsil/distribution` holds Narsil's multi-node cluster mode: nodes and roles, replication, coordinator adapters for etcd and in-process testing, TCP and gRPC transports with mutual TLS, and distributed query routing. A cluster node creates, drops, clears, writes, updates, searches, lists, counts, and suggests across every partition, and the [cluster example](examples/cluster) runs three node processes against etcd and survives a kill. The layer is experimental and its APIs change without notice, so pin an exact version before you depend on it. The [cluster guide](../../docs/cluster.md) covers the surface, and [`packages/spec/distribution`](../spec/distribution) specifies the contract every implementation follows.
+`@delali/narsil/distribution` holds Narsil's multi-node cluster mode: nodes and roles, replication, coordinator adapters for etcd and in-process testing, TCP and gRPC transports with mutual TLS, and distributed query routing. A cluster node creates, drops, clears, writes, updates, searches, lists, counts, and suggests across every partition, and the [cluster dashboard example](examples/cluster-dashboard) runs three nodes against etcd and shows what each partition does while you cut the links between them. The layer is experimental and its APIs change without notice, so pin an exact version before you depend on it. The [cluster guide](../../docs/cluster.md) covers the surface, and [`packages/spec/distribution`](../spec/distribution) specifies the contract every implementation follows.
 
 ## Search quality
 

package/dist/{chunk-GN7KF675.mjs → chunk-OOA7OBLA.mjs}

@@ -8342,6 +8342,23 @@ function partitionsFor(manager, partitionIds) {
   }
   return partitions;
 }
+function coverageFor(manager, partitionIds) {
+  if (partitionIds === void 0) {
+    return {
+      totalPartitions: manager.partitionCount,
+      queriedPartitions: manager.partitionCount,
+      timedOutPartitions: 0,
+      failedPartitions: 0
+    };
+  }
+  const queriedPartitions = partitionsFor(manager, partitionIds).length;
+  return {
+    totalPartitions: partitionIds.length,
+    queriedPartitions,
+    timedOutPartitions: 0,
+    failedPartitions: partitionIds.length - queriedPartitions
+  };
+}
 function partitionsForVectorSearch(manager, vecIndex, partitionIds) {
   if (partitionIds === void 0) {
     return void 0;
@@ -8803,7 +8820,8 @@ async function executeQuery(params, context) {
     elapsed,
     cursor: nextCursor,
     facets,
-    groups
+    groups,
+    coverage: coverageFor(manager, context.partitionIds)
   };
 }
 async function executePreflight(params, context) {

package/dist/{client-DQHB_swQ.d.ts → client-DAJ_UHOa.d.ts}

@@ -1,6 +1,6 @@
 import { e as TaskRecord, b as ImportResult, H as HttpIndexConfig, c as TaskListQuery, T as TaskListPage } from './tasks-CnMLpfk-.js';
 import { P as PartitionConfig, A as AnyDocument, a as InsertOptions } from './schema-emTQfEiX.js';
-import { V as VectorMaintenanceResult, M as MemoryStats, B as BatchResult, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, P as PartitionStatsResult, Q as QueryParams, e as QueryResult, h as PreflightResult, i as SuggestParams, j as SuggestResult } from './search-CQ-9bKxo.js';
+import { V as VectorMaintenanceResult, M as MemoryStats, B as BatchResult, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, P as PartitionStatsResult, Q as QueryParams, e as QueryResult, h as PreflightResult, i as SuggestParams, j as SuggestResult } from './search-Dt4dkzpf.js';
 
 /**
  * This is the `fetch` implementation the client sends every request through.

package/dist/client.d.ts

@@ -1,6 +1,6 @@
-export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes } from './search-CQ-9bKxo.js';
+export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes } from './search-Dt4dkzpf.js';
 export { A as ASYNC_IMPORT_CAPABILITY, E as ErrorEnvelope, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './options-BORJg5XB.js';
 export { C as CapabilitiesResponse, a as CreateIndexEmbedding, H as HttpIndexConfig, I as ImportError, b as ImportResult, T as TaskListPage, c as TaskListQuery, d as TaskProgress, e as TaskRecord, f as TaskStatus, g as TaskType } from './tasks-CnMLpfk-.js';
-export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-DQHB_swQ.js';
+export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-DAJ_UHOa.js';
 import './schema-emTQfEiX.js';
 import './adapters-79OIa4xm.js';

package/dist/{config-ChZ7lfqc.d.ts → config-CzTJJili.d.ts}

@@ -1,5 +1,5 @@
 import { P as PersistenceAdapter, I as InvalidationAdapter, E as EmbeddingAdapter } from './adapters-79OIa4xm.js';
-import { Q as QueryParams, e as QueryResult } from './search-CQ-9bKxo.js';
+import { Q as QueryParams, e as QueryResult } from './search-Dt4dkzpf.js';
 import { I as IndexConfig, A as AnyDocument } from './schema-emTQfEiX.js';
 
 /**

package/dist/distribution.d.ts

@@ -1,10 +1,10 @@
-import { N as NarsilConfig } from './config-ChZ7lfqc.js';
+import { N as NarsilConfig } from './config-CzTJJili.js';
 import { A as AllocationTable, N as NodeRole, C as ClusterCoordinator, a as NodeCapacity } from './types-BhdINMtE.js';
 export { b as AllocationConstraints, c as AllocationEvent, d as NodeEvent, e as NodeRegistration, P as PartitionAssignment, f as PartitionState, S as SchemaEvent } from './types-BhdINMtE.js';
 import { N as NodeTransport } from './types-D5OwhtsQ.js';
 export { L as ListenHandler, R as RespondFn, T as TransportConfig, a as TransportMessage } from './types-D5OwhtsQ.js';
-import { a as NarsilEventMap, N as Narsil } from './engine-DScGlT2Z.js';
-import { B as BatchResult, L as ListParams, g as ListResult, i as SuggestParams, j as SuggestResult, Q as QueryParams, h as PreflightResult, f as IndexStats, P as PartitionStatsResult, M as MemoryStats, e as QueryResult } from './search-CQ-9bKxo.js';
+import { a as NarsilEventMap, N as Narsil } from './engine-DEtRLYpB.js';
+import { B as BatchResult, L as ListParams, g as ListResult, i as SuggestParams, j as SuggestResult, Q as QueryParams, h as PreflightResult, f as IndexStats, P as PartitionStatsResult, M as MemoryStats, e as QueryResult } from './search-Dt4dkzpf.js';
 import { I as IndexConfig, A as AnyDocument, a as InsertOptions } from './schema-emTQfEiX.js';
 import './adapters-79OIa4xm.js';
 
@@ -51,9 +51,33 @@ interface ClusterNodeConfig {
     engine?: NarsilConfig;
     /** These replication settings override the engine's own, and anything you leave out keeps its value. */
     replication?: Partial<ReplicationConfig>;
+    /** These settings govern how this node gathers each search from the cluster, and anything you leave out keeps its default. */
+    query?: ClusterQueryConfig;
     /** This receives the failures the node reports while running on its own, away from any call you made. */
     onError?: (error: Error) => void;
 }
+/**
+ * How this node answers a search when one of the nodes it asked runs slowly or
+ * drops out.
+ *
+ * The defaults let a search answer from the nodes that did reply, so set
+ * `allowPartialResults` to false where a caller must never act on an
+ * incomplete count. Every search reports what it read in
+ * {@link QueryResult.coverage} whichever way you set these.
+ *
+ * @public
+ */
+interface ClusterQueryConfig {
+    /**
+     * Set this true and a search returns the hits the reachable nodes gave,
+     * counting the rest in {@link QueryResult.coverage}, which is what a node
+     * does by default. Set it false and one partition that times out, errors, or
+     * has no active copy fails the whole search with `QUERY_PARTIAL_FAILURE`.
+     */
+    allowPartialResults?: boolean;
+    /** A search waits this many milliseconds for each node before it counts that node's partitions as timed out, which is 5000 milliseconds where you name none. */
+    partitionTimeout?: number;
+}
 /**
  * How an index is spread across the cluster when a node creates it.
  *
@@ -441,4 +465,4 @@ interface ClusterEngineOptions {
  */
 declare function clusterNodeEngine(node: ClusterNode, options?: ClusterEngineOptions): Narsil;
 
-export { AllocationTable, ClusterCoordinator, type ClusterEngineOptions, type ClusterNamespace, type ClusterNode, type ClusterNodeConfig, type ClusterNodeInfo, type CreateIndexOptions, DEFAULT_CAPACITY, DEFAULT_PARTITION_COUNT, DEFAULT_REPLICATION_FACTOR, NodeCapacity, NodeRole, NodeTransport, type ReplicationConfig, clusterNodeEngine, createClusterNode };
+export { AllocationTable, ClusterCoordinator, type ClusterEngineOptions, type ClusterNamespace, type ClusterNode, type ClusterNodeConfig, type ClusterNodeInfo, type ClusterQueryConfig, type CreateIndexOptions, DEFAULT_CAPACITY, DEFAULT_PARTITION_COUNT, DEFAULT_REPLICATION_FACTOR, NodeCapacity, NodeRole, NodeTransport, type ReplicationConfig, clusterNodeEngine, createClusterNode };

package/dist/distribution.mjs

@@ -1,5 +1,5 @@
-import { createEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, now, validateIndexName, indexConfigKey, putIndexMetadata, getIndexMetadata, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, MAX_PARTITION_COUNT, clampLimit, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, MAX_SUGGEST_SCATTER_LIMIT, chunkByBudget, WIRE_BATCH_BUDGET, MAX_INDEX_NAME_LENGTH, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, createEntryMessage, computeEntryChecksum, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-GN7KF675.mjs';
-import { ReplicationMessageTypes, ClusterMessageTypes, QueryMessageTypes, TransportError, MAX_MESSAGE_SIZE_BYTES } from './chunk-36ER4WCG.mjs';
+import { createEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, now, validateIndexName, indexConfigKey, putIndexMetadata, getIndexMetadata, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, MAX_PARTITION_COUNT, clampLimit, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, MAX_SUGGEST_SCATTER_LIMIT, chunkByBudget, WIRE_BATCH_BUDGET, MAX_INDEX_NAME_LENGTH, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, createEntryMessage, computeEntryChecksum, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-OOA7OBLA.mjs';
+import { ReplicationMessageTypes, TransportErrorCodes, ClusterMessageTypes, QueryMessageTypes, TransportError, MAX_MESSAGE_SIZE_BYTES } from './chunk-36ER4WCG.mjs';
 import { deserializePayloadV2, createPartitionIndex, resolveProjection, clampRowCount, sortSignatureOf, requireMatchingCursor, decodePageCursor, normalizeSort, encodePageCursor, applyProjection, readSortValues, getLanguage, DEFAULT_PAGE_SIZE, requireWithinResultWindow, fnv1a, FILTER_EXPRESSION_KEYS, MAX_CURSOR_LENGTH, mergePartitionStats, FIELD_FILTER_OPERATORS, MAX_NESTING_DEPTH } from './chunk-RO4EFWE6.mjs';
 import './chunk-TGP5M5R7.mjs';
 import './chunk-OBXS7OZM.mjs';
@@ -237,8 +237,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 +257,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 +283,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 +397,74 @@ function initialAllocate(nodes, indexName, partitionCount, replicationFactor, co
   };
 }
 
+// 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) {
+  let heaviest;
+  for (const nodeId of shares.keys()) {
+    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);
+  assignment.primaryTerm += 1;
+}
+function rebalanceLeadership(assignments, shares) {
+  for (let swaps = 0; swaps < assignments.size; swaps++) {
+    const counts = countPrimaryAssignments(assignments);
+    const heaviest = heaviestLeader(shares, counts);
+    if (heaviest === void 0) {
+      return;
+    }
+    const swap = findSwap(assignments, heaviest, counts, shares);
+    if (swap === null) {
+      return;
+    }
+    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();
@@ -401,7 +486,27 @@ function markUnassigned(assignment) {
   assignment.inSyncSet = [];
   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 (primaryWasLost) {
@@ -420,7 +525,12 @@ function handleLostNodes(assignments, activeNodeIds) {
       markUnassigned(assignment);
       continue;
     }
-    const promoted = inSyncCandidates[0];
+    const promoted = leastLoadedCandidate(inSyncCandidates, primaryCounts, shares);
+    if (promoted === void 0) {
+      markUnassigned(assignment);
+      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 +563,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 +588,60 @@ 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 pruneInSyncSets(assignments) {
+  for (const assignment of assignments.values()) {
+    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 +654,12 @@ 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);
   const warnings = collectReplicationWarnings(assignments, currentTable.replicationFactor);
   return {
     table: {
@@ -940,15 +1087,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 +1106,8 @@ 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 updatedAssignments = new Map(table.assignments);
-    updatedAssignments.set(payload.partitionId, {
-      ...assignment,
-      state: "ACTIVE",
-      inSyncSet: ensurePrimaryInSyncSet(assignment, baseInSyncSet)
-    });
+    updatedAssignments.set(payload.partitionId, { ...assignment, state: "ACTIVE" });
     const written = await coordinator.putAllocation(
       payload.indexName,
       { ...table, version: table.version + 1, assignments: updatedAssignments },
@@ -1086,7 +1219,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 +1239,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) {
@@ -1173,7 +1309,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);
       }
@@ -6293,7 +6429,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) {
@@ -8594,9 +8731,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) {
@@ -8807,17 +8946,20 @@ function worstCaseCoverage(a, b) {
     failedPartitions: failed
   };
 }
-async function activeAllocation(deps, indexName) {
-  const allocation = await deps.config.coordinator.getAllocation(indexName);
+function servesAnyPartition(allocation) {
   if (allocation === null || allocation.assignments.size === 0) {
-    return null;
+    return false;
   }
   for (const [, assignment] of allocation.assignments) {
     if (assignment.state === "ACTIVE") {
-      return allocation;
+      return true;
     }
   }
-  return null;
+  return false;
+}
+async function activeAllocation(deps, indexName) {
+  const allocation = await deps.config.coordinator.getAllocation(indexName);
+  return servesAnyPartition(allocation) ? allocation : null;
 }
 function strictScatterGroups(allocation, indexName) {
   const routing = selectReplicasForQuery(allocation, randomSelector);
@@ -8830,8 +8972,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(
@@ -9154,11 +9318,36 @@ async function readClusterDocuments(deps, 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 queryLocalCopy(deps, indexName, params, allocation) {
+  const result = await deps.engine.query(indexName, params);
+  if (allocation === null || allocation.assignments.size === 0) {
+    return result;
+  }
+  const totalPartitions = allocation.assignments.size;
+  return {
+    ...result,
+    coverage: { totalPartitions, queriedPartitions: 0, timedOutPartitions: 0, failedPartitions: totalPartitions }
+  };
+}
 async function queryCluster(deps, indexName, params) {
-  const allocation = await activeAllocation(deps, indexName);
-  if (allocation === null) {
-    return deps.engine.query(indexName, params);
+  const table = await deps.config.coordinator.getAllocation(indexName);
+  if (!servesAnyPartition(table)) {
+    return queryLocalCopy(deps, indexName, params, table);
   }
+  const allocation = table;
   const wireParams = localParamsToWire(params);
   const queryDeps = {
     transport: deps.config.transport,
@@ -9166,7 +9355,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,
@@ -9627,6 +9816,25 @@ 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 }
+      );
+    }
+  }
 }
 
 // src/distribution/cluster-node/index.ts

package/dist/{engine-DScGlT2Z.d.ts → engine-DEtRLYpB.d.ts}

@@ -1,5 +1,5 @@
 import { E as EmbeddingAdapter } from './adapters-79OIa4xm.js';
-import { I as IndexInfo, f as IndexStats, P as PartitionStatsResult, B as BatchResult, L as ListParams, g as ListResult, Q as QueryParams, e as QueryResult, h as PreflightResult, i as SuggestParams, j as SuggestResult, M as MemoryStats, V as VectorMaintenanceResult } from './search-CQ-9bKxo.js';
+import { I as IndexInfo, f as IndexStats, P as PartitionStatsResult, B as BatchResult, L as ListParams, g as ListResult, Q as QueryParams, e as QueryResult, h as PreflightResult, i as SuggestParams, j as SuggestResult, M as MemoryStats, V as VectorMaintenanceResult } from './search-Dt4dkzpf.js';
 import { I as IndexConfig, A as AnyDocument, a as InsertOptions, P as PartitionConfig } from './schema-emTQfEiX.js';
 
 /**

package/dist/index.browser.mjs

@@ -22181,6 +22181,23 @@ function partitionsFor(manager, partitionIds) {
   }
   return partitions;
 }
+function coverageFor(manager, partitionIds) {
+  if (partitionIds === void 0) {
+    return {
+      totalPartitions: manager.partitionCount,
+      queriedPartitions: manager.partitionCount,
+      timedOutPartitions: 0,
+      failedPartitions: 0
+    };
+  }
+  const queriedPartitions = partitionsFor(manager, partitionIds).length;
+  return {
+    totalPartitions: partitionIds.length,
+    queriedPartitions,
+    timedOutPartitions: 0,
+    failedPartitions: partitionIds.length - queriedPartitions
+  };
+}
 function partitionsForVectorSearch(manager, vecIndex, partitionIds) {
   if (partitionIds === void 0) {
     return void 0;
@@ -22642,7 +22659,8 @@ async function executeQuery(params, context) {
     elapsed,
     cursor: nextCursor,
     facets,
-    groups
+    groups,
+    coverage: coverageFor(manager, context.partitionIds)
   };
 }
 async function executePreflight(params, context) {

package/dist/index.d.ts

@@ -2,11 +2,11 @@ import { c as StopWordOverride, C as CustomTokenizer } from './schema-emTQfEiX.j
 export { A as AnyDocument, B as BM25Params, E as EmbeddingFieldConfig, F as FieldType, I as IndexConfig, a as InsertOptions, P as PartitionConfig, S as SchemaDefinition, b as ScoringMode, V as VectorIndexConfig, d as VectorQuantizationMode } from './schema-emTQfEiX.js';
 import { L as LanguageModule } from './language-DB8KG1z5.js';
 export { T as TokenizerConfig } from './language-DB8KG1z5.js';
-export { A as ArrayFilter, B as BatchResult, C as ClientErrorCode, a as ClientErrorCodes, k as ComparisonFilter, D as DocumentProjection, E as ErrorCode, b as ErrorCodes, F as FacetConfig, l as FacetResult, m as FieldFilter, n as FilterExpression, G as GeoFilter, o as GeoPolygonFilter, p as GeoRadiusFilter, q as GroupConfig, r as GroupReducer, s as GroupResult, H as HighlightConfig, t as HighlightMatch, u as Hit, v as HybridConfig, I as IndexInfo, f as IndexStats, L as ListParams, g as ListResult, w as ListedDocument, M as MemoryStats, N as NarsilError, c as NarsilErrorCode, P as PartitionStatsResult, h as PreflightResult, x as PresenceFilter, y as ProcessMemoryReport, Q as QueryParams, e as QueryResult, z as ScoreComponents, J as SearchMode, S as ServerErrorCode, d as ServerErrorCodes, K as SortField, O as SortSpec, R as StringFilter, i as SuggestParams, j as SuggestResult, T as TermMatchPolicy, V as VectorMaintenanceResult, U as VectorQueryConfig } from './search-CQ-9bKxo.js';
-import { N as NarsilConfig } from './config-ChZ7lfqc.js';
-export { A as AnalysisConfig, D as DurabilityConfig, I as IndexContext, a as InsertContext, b as NarsilPlugin, P as PartitionContext, R as RemoveContext, S as SearchContext, c as StaleAnalysis, U as UpdateContext, W as WorkerConfig, d as WorkerContext } from './config-ChZ7lfqc.js';
-import { N as Narsil } from './engine-DScGlT2Z.js';
-export { a as NarsilEventMap } from './engine-DScGlT2Z.js';
+export { A as ArrayFilter, B as BatchResult, C as ClientErrorCode, a as ClientErrorCodes, k as ComparisonFilter, D as DocumentProjection, E as ErrorCode, b as ErrorCodes, F as FacetConfig, l as FacetResult, m as FieldFilter, n as FilterExpression, G as GeoFilter, o as GeoPolygonFilter, p as GeoRadiusFilter, q as GroupConfig, r as GroupReducer, s as GroupResult, H as HighlightConfig, t as HighlightMatch, u as Hit, v as HybridConfig, I as IndexInfo, f as IndexStats, L as ListParams, g as ListResult, w as ListedDocument, M as MemoryStats, N as NarsilError, c as NarsilErrorCode, P as PartitionStatsResult, h as PreflightResult, x as PresenceFilter, y as ProcessMemoryReport, z as QueryCoverage, Q as QueryParams, e as QueryResult, J as ScoreComponents, K as SearchMode, S as ServerErrorCode, d as ServerErrorCodes, O as SortField, R as SortSpec, T as StringFilter, i as SuggestParams, j as SuggestResult, U as TermMatchPolicy, V as VectorMaintenanceResult, W as VectorQueryConfig } from './search-Dt4dkzpf.js';
+import { N as NarsilConfig } from './config-CzTJJili.js';
+export { A as AnalysisConfig, D as DurabilityConfig, I as IndexContext, a as InsertContext, b as NarsilPlugin, P as PartitionContext, R as RemoveContext, S as SearchContext, c as StaleAnalysis, U as UpdateContext, W as WorkerConfig, d as WorkerContext } from './config-CzTJJili.js';
+import { N as Narsil } from './engine-DEtRLYpB.js';
+export { a as NarsilEventMap } from './engine-DEtRLYpB.js';
 export { E as EmbeddingAdapter, I as InvalidationAdapter, a as InvalidationEvent, b as PartitionStatistics, P as PersistenceAdapter } from './adapters-79OIa4xm.js';
 
 /**

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { VERSION, createNarsil } from './chunk-GN7KF675.mjs';
+export { VERSION, createNarsil } from './chunk-OOA7OBLA.mjs';
 import './chunk-36ER4WCG.mjs';
 export { clearNormalizationCache, configureNormalizationCache, getLanguage, getNormalizationCacheSize, getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerLanguage, registerStopWords, registerTokenizer, resetNormalizationCache } from './chunk-RO4EFWE6.mjs';
 import './chunk-TGP5M5R7.mjs';

package/dist/persistence/durability/checkpoint-worker.mjs

@@ -1,4 +1,4 @@
-import { createDurableDirectory, writeSegmentedCheckpoint } from '../../chunk-GN7KF675.mjs';
+import { createDurableDirectory, writeSegmentedCheckpoint } from '../../chunk-OOA7OBLA.mjs';
 import '../../chunk-36ER4WCG.mjs';
 import '../../chunk-RO4EFWE6.mjs';
 import '../../chunk-TGP5M5R7.mjs';

package/dist/react.d.ts

@@ -1,9 +1,9 @@
-import { N as NarsilError, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, Q as QueryParams, h as PreflightResult, e as QueryResult, i as SuggestParams, j as SuggestResult } from './search-CQ-9bKxo.js';
-export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes } from './search-CQ-9bKxo.js';
+import { N as NarsilError, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, Q as QueryParams, h as PreflightResult, e as QueryResult, i as SuggestParams, j as SuggestResult } from './search-Dt4dkzpf.js';
+export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes } from './search-Dt4dkzpf.js';
 import { e as TaskRecord, d as TaskProgress, b as ImportResult, c as TaskListQuery, T as TaskListPage } from './tasks-CnMLpfk-.js';
 export { I as ImportError, f as TaskStatus, g as TaskType } from './tasks-CnMLpfk-.js';
 import { ReactNode, ReactElement } from 'react';
-import { N as NarsilClient, I as ImportSource } from './client-DQHB_swQ.js';
+import { N as NarsilClient, I as ImportSource } from './client-DAJ_UHOa.js';
 import { A as AnyDocument } from './schema-emTQfEiX.js';
 import './adapters-79OIa4xm.js';
 

package/dist/{search-CQ-9bKxo.d.ts → search-Dt4dkzpf.d.ts}

@@ -229,6 +229,29 @@ interface QueryResult<T = AnyDocument> {
     groups?: GroupResult[];
     /** This turns true when the index's terms came from an older analysis than its language module produces now. */
     analysisStale?: boolean;
+    /** The search read this much of the index, which is how you spot a degraded answer. */
+    coverage: QueryCoverage;
+}
+/**
+ * How much of an index one search read, which is what you check before you
+ * trust a count or a ranking.
+ *
+ * An embedded engine reads every partition it holds, so `queriedPartitions`
+ * matches `totalPartitions` there and the other two stay zero. A search across
+ * a cluster may find a node slow or unreachable, which it counts here while
+ * still returning the hits the other nodes gave it.
+ *
+ * @public
+ */
+interface QueryCoverage {
+    /** The search should have read this many partitions. */
+    totalPartitions: number;
+    /** The search read this many of them. */
+    queriedPartitions: number;
+    /** The search counts a partition here when the node holding it took longer than the query allowed. */
+    timedOutPartitions: number;
+    /** The search counts a partition here when the node holding it returned an error, and when no active replica served it. */
+    failedPartitions: number;
 }
 /**
  * One matching document, with the score that ranked it.
@@ -996,4 +1019,4 @@ interface ListParams {
     document?: DocumentProjection;
 }
 
-export { type ArrayFilter as A, type BatchResult as B, type ClientErrorCode as C, type DocumentProjection as D, type ErrorCode as E, type FacetConfig as F, type GeoFilter as G, type HighlightConfig as H, type IndexInfo as I, type SearchMode as J, type SortField as K, type ListParams as L, type MemoryStats as M, NarsilError as N, type SortSpec as O, type PartitionStatsResult as P, type QueryParams as Q, type StringFilter as R, type ServerErrorCode as S, type TermMatchPolicy as T, type VectorQueryConfig as U, type VectorMaintenanceResult as V, ClientErrorCodes as a, ErrorCodes as b, type NarsilErrorCode as c, ServerErrorCodes as d, type QueryResult as e, type IndexStats as f, type ListResult as g, type PreflightResult as h, type SuggestParams as i, type SuggestResult as j, type ComparisonFilter as k, type FacetResult as l, type FieldFilter as m, type FilterExpression as n, type GeoPolygonFilter as o, type GeoRadiusFilter as p, type GroupConfig as q, type GroupReducer as r, type GroupResult as s, type HighlightMatch as t, type Hit as u, type HybridConfig as v, type ListedDocument as w, type PresenceFilter as x, type ProcessMemoryReport as y, type ScoreComponents as z };
+export { type ArrayFilter as A, type BatchResult as B, type ClientErrorCode as C, type DocumentProjection as D, type ErrorCode as E, type FacetConfig as F, type GeoFilter as G, type HighlightConfig as H, type IndexInfo as I, type ScoreComponents as J, type SearchMode as K, type ListParams as L, type MemoryStats as M, NarsilError as N, type SortField as O, type PartitionStatsResult as P, type QueryParams as Q, type SortSpec as R, type ServerErrorCode as S, type StringFilter as T, type TermMatchPolicy as U, type VectorMaintenanceResult as V, type VectorQueryConfig as W, ClientErrorCodes as a, ErrorCodes as b, type NarsilErrorCode as c, ServerErrorCodes as d, type QueryResult as e, type IndexStats as f, type ListResult as g, type PreflightResult as h, type SuggestParams as i, type SuggestResult as j, type ComparisonFilter as k, type FacetResult as l, type FieldFilter as m, type FilterExpression as n, type GeoPolygonFilter as o, type GeoRadiusFilter as p, type GroupConfig as q, type GroupReducer as r, type GroupResult as s, type HighlightMatch as t, type Hit as u, type HybridConfig as v, type ListedDocument as w, type PresenceFilter as x, type ProcessMemoryReport as y, type QueryCoverage as z };

package/dist/server.d.ts

@@ -1,9 +1,9 @@
 import { b as ServerOptions, N as NarsilServer } from './options-BORJg5XB.js';
 export { A as ASYNC_IMPORT_CAPABILITY, C as CorsOptions, E as ErrorEnvelope, O as OnRequestHook, R as REBUILD_ANALYSIS_CAPABILITY, c as RequestContext, d as RequestDenial, S as SERVER_CAPABILITIES, e as ServerLimits, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './options-BORJg5XB.js';
-import { N as Narsil } from './engine-DScGlT2Z.js';
+import { N as Narsil } from './engine-DEtRLYpB.js';
 import { h as TaskStore, e as TaskRecord, d as TaskProgress, b as ImportResult } from './tasks-CnMLpfk-.js';
 export { C as CapabilitiesResponse, a as CreateIndexEmbedding, i as CreateIndexRequest, H as HttpIndexConfig, I as ImportError, T as TaskListPage, c as TaskListQuery, f as TaskStatus, g as TaskType } from './tasks-CnMLpfk-.js';
-export { d as ServerErrorCodes } from './search-CQ-9bKxo.js';
+export { d as ServerErrorCodes } from './search-Dt4dkzpf.js';
 import './adapters-79OIa4xm.js';
 import './schema-emTQfEiX.js';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delali/narsil",
-  "version": "0.2.3-next.34",
+  "version": "0.2.3-next.35",
   "type": "module",
   "description": "A distributed full-text search engine with cross-language portable binary format.",
   "author": "Delali (https://sondelali.com)",