@delali/narsil 0.2.4-next.48 → 0.2.4-next.50

package/dist/{chunk-UZTT2BKQ.mjs → chunk-ND34I3SV.mjs}

@@ -1,14 +1,21 @@
-import { ReplicationMessageTypes } from './chunk-JQUL2T6I.mjs';
-import { MAX_INDEX_NAME_LENGTH } from './chunk-XWICBGYT.mjs';
-import { getNestedValue, getLanguage, extractVectorFieldsFromSchema, createDirectExecutor, createPartitionRouter, clampRowCount, DEFAULT_PAGE_SIZE, validateSchema, validateVectorPromotion, collectQueryTermStats, createPartitionManager, createVectorIndex, flattenSchema, isTextFieldType, fnv1aBytes, requireWithinResultWindow, normalizeSort, sortSignatureOf, requireSortableFields, fanOutQuery, applySorting, applyPagination, resolveProjection, countsWithoutScores, fanOutMatchCount, tokenize, decodePageCursor, requireMatchingCursor, encodePageCursor, resolveIndexAnalysis, deserializePayloadV2, deserializePayloadV1, mergePartitionStats, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, createPartitionIndex, fnv1a, createWorkerPool, partitionsIn, detectRuntime, isNodeMainThread, spawnNodeWorker, createSharedFrozenSegment, buildCompactedSegmentPayload, freezeSegmentShared, createFrozenSegment, deserializeMetadata, isCompositePartition, serializeMetadata, kWayMerge, validateRequiredFields, validateDocument, validateDocumentStrict } from './chunk-EV45L35L.mjs';
+import { validateWorkerConfig, validateIndexName, validateBM25Params, validatePartitionConfig, executeQuery, queryBindingOf, executePreflight, executeSuggest, executeListDocuments, validateDocId } from './chunk-ZHUQKZBE.mjs';
+import { ReplicationMessageTypes } from './chunk-GCM3JFVA.mjs';
+import { WIRE_BATCH_BUDGET, resolveVectorText, bindEngineCore } from './chunk-PIWKZPP7.mjs';
+import { STATISTICS_BROADCAST_INTERVAL_MS, MAX_SWEEP_INTERVAL_MS, MIN_SWEEP_INTERVAL_MS, HEAP_PRESSURE_WARNING_FRACTION, FOREIGN_STATS_TTL_MS, HEAP_PRESSURE_REARM_FRACTION, MIN_DOCUMENTS_FOR_SEGMENTS, BATCH_CHUNK_SIZE } from './chunk-XE6XR2OE.mjs';
+import { getNestedValue, generateId, getLanguage, splitWorkerBudget, resolveWorkerCount, createDirectExecutor, createPartitionRouter, createPartitionManager, createVectorIndex, readHeapStatistics, resolveIndexAnalysis, deserializePayloadV2, deserializePayloadV1, resolveRequestThreadCount, createPartitionIndex, createWorkerPool, isNodeMainThread, spawnNodeWorker, CHECKSUM_TIMEOUT_MS, CHECKSUM_YIELD_CHUNK_BYTES, createSharedFrozenSegment, buildCompactedSegmentPayload, freezeSegmentShared, createFrozenSegment, isCompositePartition, WORKER_RESOURCE_LIMITS, deserializeMetadata, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, serializeMetadata, SHUTDOWN_TIMEOUT_MS, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, encodeSegmentState } from './chunk-BEIK3EOZ.mjs';
+import { extractVectorFieldsFromSchema, validateSchema, validateVectorPromotion, collectQueryTermStats, flattenSchema, isTextFieldType, mergePartitionStats, fnv1a, kWayMerge, mergeFacets, validateRequiredFields, validateDocument, validateDocumentStrict } from './chunk-CMVG2UEF.mjs';
+import { detectRuntime } from './chunk-AV4IJKD2.mjs';
 import { crc32, crc32Init, crc32Update, crc32Final } from './chunk-KMMJMDUA.mjs';
-import { compareCodePoints, compareComparableKeys } from './chunk-BFIH7OV5.mjs';
-import { generateId, createRequestId, isValidWorkerResponse } from './chunk-WTONLDU3.mjs';
+import { compareCodePoints } from './chunk-2GWVQWGA.mjs';
+import { createRequestId, isValidWorkerResponse } from './chunk-WYJXSLER.mjs';
 import { ErrorCodes, NarsilError } from './chunk-P4ELXVJQ.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
+// src/partitioning/constants.ts
+var REBALANCE_CHUNK_SIZE = 1e3;
+var DEFAULT_WRITE_AHEAD_QUEUE_MAX_SIZE = 1e4;
+
 // src/partitioning/rebalancer.ts
-var CHUNK_SIZE = 1e3;
 function createRebalancer() {
   const activeManagers = /* @__PURE__ */ new WeakSet();
   let activeCount = 0;
@@ -71,7 +78,7 @@ function createRebalancer() {
             documentsProcessed++;
           }
           chunkFill++;
-          if (chunkFill >= CHUNK_SIZE) {
+          if (chunkFill >= REBALANCE_CHUNK_SIZE) {
             chunkFill = 0;
             onProgress?.({
               phase: "moving",
@@ -269,42 +276,18 @@ function validateRequiredFieldsInSchema(required, schema) {
   }
 }
 
-// src/workers/promoter.ts
-var DEFAULT_PER_INDEX_THRESHOLD = 1e4;
-var DEFAULT_TOTAL_THRESHOLD = 5e4;
-function createExecutionPromoter(config) {
-  const perIndexThreshold = config?.perIndexThreshold ?? DEFAULT_PER_INDEX_THRESHOLD;
-  const totalThreshold = config?.totalThreshold ?? DEFAULT_TOTAL_THRESHOLD;
-  let promoted = false;
-  function check(indexes) {
-    if (promoted) {
-      return { shouldPromote: false, reason: "" };
-    }
-    let totalDocuments = 0;
-    for (const [indexName, stats] of indexes) {
-      if (stats.documentCount >= perIndexThreshold) {
-        return {
-          shouldPromote: true,
-          reason: `Index "${indexName}" has ${stats.documentCount} documents, exceeding the per-index threshold of ${perIndexThreshold}`
-        };
-      }
-      totalDocuments += stats.documentCount;
-    }
-    if (totalDocuments >= totalThreshold) {
-      return {
-        shouldPromote: true,
-        reason: `Total document count of ${totalDocuments} exceeds the total threshold of ${totalThreshold}`
-      };
+// src/engine/events.ts
+function emitEngineEvent(eventHandlers, event, payload) {
+  const handlers = eventHandlers.get(event);
+  if (!handlers || handlers.size === 0) return 0;
+  for (const handler of handlers) {
+    try {
+      handler(payload);
+    } catch (err) {
+      console.warn(`${event} handler error:`, err instanceof Error ? err.message : String(err));
     }
-    return { shouldPromote: false, reason: "" };
   }
-  function markPromoted() {
-    promoted = true;
-  }
-  function isPromoted() {
-    return promoted;
-  }
-  return { check, markPromoted, isPromoted };
+  return handlers.size;
 }
 
 // src/engine/analysis-rebuild.ts
@@ -328,15 +311,7 @@ function wireAnalysisRebuild(wiring) {
       await (durability.checkpointFromMemory?.(indexName) ?? durability.checkpoint(indexName));
     },
     emit(payload) {
-      const handlers = wiring.eventHandlers.get("analysisRebuild");
-      if (!handlers) return;
-      for (const handler of handlers) {
-        try {
-          handler(payload);
-        } catch (err) {
-          console.warn("analysisRebuild handler error:", err instanceof Error ? err.message : String(err));
-        }
-      }
+      emitEngineEvent(wiring.eventHandlers, "analysisRebuild", payload);
     }
   });
 }
@@ -383,7 +358,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
       throw error;
     }
   }
-  function enqueue2(indexName, entry) {
+  function enqueue(indexName, entry) {
     if (entry.run !== null) {
       return entry.run;
     }
@@ -397,7 +372,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
   }
   async function announce(indexName, entry) {
     const documentCount = deps.getManager(indexName)?.countDocuments() ?? 0;
-    await config?.onStaleAnalysis?.({ ...entry.index, documentCount }, () => enqueue2(indexName, entry));
+    await config?.onStaleAnalysis?.({ ...entry.index, documentCount }, () => enqueue(indexName, entry));
   }
   async function review(indexName, entry) {
     if (entry.run !== null || deps.getManager(indexName) === void 0) return;
@@ -413,7 +388,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
       });
     }
     if (rebuildMode === "auto") {
-      void enqueue2(indexName, entry).catch(() => void 0);
+      void enqueue(indexName, entry).catch(() => void 0);
     }
   }
   return {
@@ -447,7 +422,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
       if (entry === void 0) {
         return Promise.resolve();
       }
-      return enqueue2(indexName, entry);
+      return enqueue(indexName, entry);
     }
   };
 }
@@ -532,6 +507,15 @@ function resolveDurabilityTier(config) {
   return { kind: "snapshot", config: {}, adapter: config.persistence };
 }
 
+// src/persistence/durability/constants.ts
+var DEFAULT_CHECKPOINT_INTERVAL_MS = 3e5;
+var DEFAULT_CHECKPOINT_MUTATION_THRESHOLD = 1e5;
+var DEFAULT_ASYNC_FLUSH_INTERVAL_MS = 1e3;
+var DEFAULT_SEGMENT_MAX_BYTES = 67108864;
+var DEFAULT_COMPACTION_THRESHOLD = 12;
+var CHECKPOINT_WORKER_TIMEOUT_MS = 6e5;
+var CHECKPOINT_TIMEOUT_RECOVERY_BACKOFF_MS = 50;
+
 // src/persistence/durability/node-fs.ts
 var cachedFs = null;
 var cachedPath = null;
@@ -809,8 +793,6 @@ function buildEntry(fields) {
 }
 
 // src/serialization/checksum-dispatch.ts
-var CHECKSUM_TIMEOUT_MS = 12e4;
-var YIELD_CHUNK_BYTES = 4 * 1024 * 1024;
 var workerUsable = true;
 var mainThreadResolved = false;
 var onMainThread = true;
@@ -844,8 +826,8 @@ function yieldToEventLoop2() {
 }
 async function chunkedChecksum(payload) {
   let state = crc32Init();
-  for (let offset = 0; offset < payload.length; offset += YIELD_CHUNK_BYTES) {
-    const end = Math.min(offset + YIELD_CHUNK_BYTES, payload.length);
+  for (let offset = 0; offset < payload.length; offset += CHECKSUM_YIELD_CHUNK_BYTES) {
+    const end = Math.min(offset + CHECKSUM_YIELD_CHUNK_BYTES, payload.length);
     state = crc32Update(state, payload.subarray(offset, end));
     if (end < payload.length) {
       await yieldToEventLoop2();
@@ -855,7 +837,7 @@ async function chunkedChecksum(payload) {
 }
 function runWorkerChecksum(worker, payload) {
   return new Promise((resolve, reject) => {
-    let settled = false;
+    let settled2 = false;
     const timeoutId = setTimeout(
       () => settle(() => reject(new Error(`Checksum worker timed out after ${CHECKSUM_TIMEOUT_MS}ms`))),
       CHECKSUM_TIMEOUT_MS
@@ -864,8 +846,8 @@ function runWorkerChecksum(worker, payload) {
       timeoutId.unref();
     }
     function settle(action) {
-      if (settled) return;
-      settled = true;
+      if (settled2) return;
+      settled2 = true;
       clearTimeout(timeoutId);
       try {
         void worker.terminate();
@@ -1437,8 +1419,6 @@ function formatSegmentStart(startSeqNo) {
 }
 
 // src/persistence/durability/checkpoint-worker-dispatch.ts
-var CHECKPOINT_WORKER_TIMEOUT_MS = 6e5;
-var TIMEOUT_RECOVERY_BACKOFF_MS = 50;
 var workerUsable2 = true;
 var pooledWorker = null;
 var workerBusy = false;
@@ -1477,7 +1457,7 @@ function discardWorker(worker) {
 }
 function runWorker(worker, request) {
   return new Promise((resolve) => {
-    let settled = false;
+    let settled2 = false;
     const onMessage = (msg) => {
       const response = msg;
       if (response.type === "success") {
@@ -1497,10 +1477,10 @@ function runWorker(worker, request) {
       timeoutId.unref();
     }
     function settle(outcome, discard) {
-      if (settled) {
+      if (settled2) {
         return;
       }
-      settled = true;
+      settled2 = true;
       clearTimeout(timeoutId);
       worker.off("message", onMessage);
       worker.off("error", onError);
@@ -1551,7 +1531,7 @@ async function runCheckpointOnWorker(request) {
       return true;
     }
     if (outcome.timedOut) {
-      await delay(TIMEOUT_RECOVERY_BACKOFF_MS);
+      await delay(CHECKPOINT_TIMEOUT_RECOVERY_BACKOFF_MS);
     }
     return false;
   } finally {
@@ -1571,7 +1551,6 @@ function terminateCheckpointWorker() {
 }
 
 // src/persistence/durability/segment/layout.ts
-var DEFAULT_COMPACTION_THRESHOLD = 12;
 var SEGMENT_ID_WIDTH = 16;
 function manifestKey(indexName) {
   return `${indexName}/manifest`;
@@ -2513,37 +2492,6 @@ function setNestedValue(obj, path, value) {
   }
   current[finalSegment] = value;
 }
-
-// src/distribution/chunking.ts
-var WIRE_BATCH_BUDGET = {
-  maxCount: 1e3,
-  maxBytes: 8388608,
-  overheadBytes: 256
-};
-function chunkByBudget(items, budget) {
-  const chunks = [];
-  let current = [];
-  let currentBytes = 0;
-  for (const item of items) {
-    const itemBytes = budget.payloadBytesOf(item) + budget.overheadBytes;
-    const previous = current[current.length - 1];
-    const breaksRun = previous !== void 0 && budget.breaksRun?.(item, previous) === true;
-    const overflows = current.length >= budget.maxCount || current.length > 0 && currentBytes + itemBytes > budget.maxBytes;
-    if (breaksRun || overflows) {
-      chunks.push(current);
-      current = [];
-      currentBytes = 0;
-    }
-    current.push(item);
-    currentBytes += itemBytes;
-  }
-  if (current.length > 0) {
-    chunks.push(current);
-  }
-  return chunks;
-}
-
-// src/distribution/replication/codec.ts
 function createEntryMessage(entry, sourceId) {
   const payload = { entry };
   return {
@@ -3266,7 +3214,10 @@ async function writePartitionVectors(input) {
   }
   const vectorIndexes = /* @__PURE__ */ new Map();
   for (const [fieldPath, dimension] of input.vectorFields) {
-    vectorIndexes.set(fieldPath, createVectorIndex(fieldPath, dimension, input.config.vectorPromotion));
+    vectorIndexes.set(
+      fieldPath,
+      createVectorIndex(fieldPath, dimension, input.config.vectorPromotion, { enabled: false })
+    );
   }
   for (const ref of input.priorVectors) {
     const vecIndex = vectorIndexes.get(ref.fieldPath);
@@ -3684,11 +3635,6 @@ async function recoverPersistedIndex(deps, indexName, metadataOnly) {
   }
 }
 
-// src/persistence/durability/types.ts
-var DEFAULT_CHECKPOINT_INTERVAL_MS = 3e5;
-var DEFAULT_CHECKPOINT_MUTATION_THRESHOLD = 1e5;
-var DEFAULT_ASYNC_FLUSH_INTERVAL_MS = 1e3;
-
 // src/persistence/durability/group-commit.ts
 function createGroupCommitCoordinator(sync) {
   let inFlight = null;
@@ -3762,7 +3708,6 @@ async function createMarkerWriter(directory, indexName, partitionId) {
 }
 
 // src/persistence/durability/wal-writer.ts
-var DEFAULT_SEGMENT_MAX_BYTES = 67108864;
 var SEGMENT_TAIL_PATTERN = /^\d{16}$/;
 function segmentKey2(indexName, partitionId, startSeqNo) {
   const padded = startSeqNo.toString().padStart(16, "0");
@@ -4680,11 +4625,11 @@ function createDurabilityFromTier(tier, wiring) {
   });
 }
 
-// src/engine/index-state/entry.ts
+// src/engine/index-state/constants.ts
 var DEFAULT_MAX_REOPEN_WAITERS = 64;
 var MAX_REOPEN_FAILURES = 5;
-var MIN_SWEEP_INTERVAL_MS = 100;
-var MAX_SWEEP_INTERVAL_MS = 6e4;
+
+// src/engine/index-state/entry.ts
 function createLifecycleEntry(state) {
   return {
     state,
@@ -4958,7 +4903,10 @@ function createIndexStateCoordinator(config, callbacks) {
         await reopen(indexName, false);
         entry = entryOf(indexName);
       }
-      if (markActive) entry.lastAccessAt = Date.now();
+      if (markActive) {
+        entry.lastAccessAt = Date.now();
+        callbacks.onAccess?.(indexName);
+      }
       entry.activeOperations += 1;
       try {
         if (opened) await enforceLimits(indexName);
@@ -5061,6 +5009,9 @@ function wireIndexState(wiring) {
         }
       }
     },
+    onAccess(indexName) {
+      wiring.onAccess?.(indexName);
+    },
     canCloseAutomatically(indexName) {
       return !rebalancingIndexes.has(indexName) && !analysisRebuild.isRunning(indexName) && !orchestrator.isIndexBusy(indexName);
     },
@@ -5071,8 +5022,6 @@ function wireIndexState(wiring) {
 }
 
 // src/engine/invalidation.ts
-var STATISTICS_BROADCAST_INTERVAL_MS = 5e3;
-var FOREIGN_STATS_TTL_MS = 6e4;
 function createInvalidationFromConfig(config, tierKind, deps) {
   if (config?.invalidation === void 0) {
     return null;
@@ -5226,41 +5175,222 @@ function createInvalidationIntegration(deps) {
   };
 }
 
+// src/engine/heap-pressure.ts
+function createHeapPressureNotifier(deps) {
+  let warned = false;
+  function check(indexName) {
+    const heap = deps.readHeap();
+    if (heap === null) return;
+    const fraction = heap.usedBytes / heap.limitBytes;
+    if (warned) {
+      if (fraction < HEAP_PRESSURE_REARM_FRACTION) warned = false;
+      return;
+    }
+    if (fraction < HEAP_PRESSURE_WARNING_FRACTION) return;
+    warned = true;
+    deps.emit({
+      indexName,
+      heapUsed: heap.usedBytes,
+      heapLimit: heap.limitBytes,
+      estimatedMemoryBytes: deps.estimateIndexBytes(indexName)
+    });
+  }
+  return { check };
+}
+
+// src/engine/watermark.ts
+function createWatermarkNotifier(deps) {
+  const latchedCapacity = /* @__PURE__ */ new Map();
+  function check(indexName) {
+    const partitionConfig = deps.getPartitionConfig(indexName);
+    const maxDocs = partitionConfig?.maxDocsPerPartition;
+    const watermark = partitionConfig?.watermark;
+    if (maxDocs === void 0 || watermark === void 0) {
+      latchedCapacity.delete(indexName);
+      return;
+    }
+    const manager = deps.getManager(indexName);
+    if (!manager) {
+      latchedCapacity.delete(indexName);
+      return;
+    }
+    const partitionCount = manager.partitionCount;
+    const capacity = maxDocs * partitionCount;
+    const documentCount = manager.countDocuments();
+    const threshold = watermark * capacity;
+    if (documentCount < threshold) {
+      latchedCapacity.delete(indexName);
+      return;
+    }
+    if (latchedCapacity.get(indexName) === capacity) return;
+    latchedCapacity.set(indexName, capacity);
+    deps.emit({ indexName, documentCount, capacity, partitionCount });
+  }
+  function forget(indexName) {
+    latchedCapacity.delete(indexName);
+  }
+  return { check, forget };
+}
+
+// src/engine/notifiers.ts
+function wireWatermarkNotifier(wiring) {
+  return createWatermarkNotifier({
+    getManager: wiring.getManager,
+    getPartitionConfig: (indexName) => wiring.indexRegistry.get(indexName)?.config.partitions,
+    emit: (payload) => emitEngineEvent(wiring.eventHandlers, "partitionWatermark", payload)
+  });
+}
+function warnUnheardHeapPressure(payload) {
+  console.warn(
+    `Heap at ${payload.heapUsed} of ${payload.heapLimit} bytes after index "${payload.indexName}"; raise --max-old-space-size-percentage or close an idle index`
+  );
+}
+function wireHeapPressureNotifier(wiring) {
+  return createHeapPressureNotifier({
+    readHeap: readHeapStatistics,
+    estimateIndexBytes: (indexName) => wiring.getManager(indexName)?.estimateMemoryBytes() ?? 0,
+    emit: (payload) => {
+      if (emitEngineEvent(wiring.eventHandlers, "heapPressure", payload) === 0) warnUnheardHeapPressure(payload);
+    }
+  });
+}
+function checkHeapAfterRecovery(core) {
+  const sized = [...core.indexRegistry.keys()].map((indexName) => ({
+    indexName,
+    bytes: core.executor.getManager(indexName)?.estimateMemoryBytes() ?? 0
+  }));
+  sized.sort((a, b) => b.bytes - a.bytes);
+  for (const { indexName } of sized) core.heapPressureNotifier.check(indexName);
+}
+
+// src/core/partition/frozen/share.ts
+function shareFrozenSegment(segment) {
+  if (segment.sharedSnapshot !== null) {
+    return { snapshot: segment.sharedSnapshot, tombstonedDocIds: segment.tombstonedDocIds() };
+  }
+  const payload = encodeSegmentState(segment);
+  const documents = payload.docIds.map((docId) => {
+    const stored = segment.docStore.get(docId);
+    if (stored === void 0) {
+      throw new NarsilError(ErrorCodes.PARTITION_CORRUPTED, `Document "${docId}" vanished while sharing a segment`, {
+        docId
+      });
+    }
+    return stored.fields;
+  });
+  const snapshot = freezeSegmentShared(payload, documents, segment.segmentId);
+  return snapshot === null ? null : { snapshot, tombstonedDocIds: [] };
+}
+
 // src/engine/worker-resync.ts
-async function transferIndexToPool(indexName, pool, config, manager) {
-  const allExecutors = pool.getAllExecutors();
+function captureComposite(manager, partitionId) {
+  const partition = manager.getPartition(partitionId);
+  if (!isCompositePartition(partition)) return null;
+  const segmentIds = partition.frozenSegmentSizes().map((size) => size.segmentId);
+  const frozen = [];
+  for (const segment of partition.frozenSegmentsById(segmentIds)) {
+    const shared = shareFrozenSegment(segment);
+    if (shared === null) return null;
+    frozen.push(shared);
+  }
+  const live = partition.live.serialize(
+    manager.indexName,
+    manager.partitionCount,
+    manager.language.name,
+    manager.schema
+  );
+  return { partitionId, live, frozen };
+}
+function capturePartitions(manager) {
+  const captured = [];
+  for (let partitionId = 0; partitionId < manager.partitionCount; partitionId++) {
+    captured.push(
+      captureComposite(manager, partitionId) ?? {
+        partitionId,
+        live: manager.serializePartition(partitionId),
+        frozen: []
+      }
+    );
+  }
+  return captured;
+}
+async function sendPartition(indexName, executors, captured) {
+  await Promise.all(
+    executors.map(
+      (workerExecutor) => workerExecutor.execute({
+        type: "deserialize",
+        indexName,
+        partitionId: captured.partitionId,
+        data: captured.live,
+        requestId: `resync-${indexName}-${captured.partitionId}`
+      })
+    )
+  );
+  if (captured.frozen.length === 0) return;
+  const segments = captured.frozen.map((shared) => ({
+    partitionId: captured.partitionId,
+    snapshot: shared.snapshot,
+    tombstonedDocIds: shared.tombstonedDocIds
+  }));
+  await Promise.all(
+    executors.map(
+      (workerExecutor) => workerExecutor.execute({
+        type: "attachSegments",
+        indexName,
+        segments,
+        requestId: `resync-attach-${indexName}-${captured.partitionId}`
+      })
+    )
+  );
+}
+async function transferIndexToPool(indexName, pool, config, manager, analysisStale = false) {
+  await loadIndexOntoWorkers(
+    indexName,
+    pool.getAllExecutors(),
+    config,
+    manager,
+    () => pool.addIndexToAll(indexName),
+    analysisStale
+  );
+}
+async function loadIndexOntoWorkers(indexName, executors, config, manager, onDropped, analysisStale = false) {
+  const captured = capturePartitions(manager);
   await Promise.allSettled(
-    allExecutors.map(
+    executors.map(
       (workerExecutor) => workerExecutor.execute({ type: "dropIndex", indexName, requestId: `resync-drop-${indexName}` })
     )
   );
-  pool.addIndexToAll(indexName);
+  onDropped?.();
   await Promise.all(
-    allExecutors.map(
+    executors.map(
       (workerExecutor) => workerExecutor.execute({
         type: "createIndex",
         indexName,
         config,
-        requestId: `resync-create-${indexName}`
+        requestId: `resync-create-${indexName}`,
+        analysisStale
       })
     )
   );
-  for (let i = 0; i < manager.partitionCount; i++) {
-    const serialized = manager.serializePartition(i);
-    await Promise.all(
-      allExecutors.map(
-        (workerExecutor) => workerExecutor.execute({
-          type: "deserialize",
-          indexName,
-          partitionId: i,
-          data: serialized,
-          requestId: `resync-${indexName}-${i}`
-        })
-      )
-    );
+  for (const partition of captured) {
+    await sendPartition(indexName, executors, partition);
   }
 }
 
+// src/engine/orchestration/constants.ts
+var DEFAULT_COPY_THRESHOLD = 1e3;
+var DEFAULT_COPY_IDLE_TIMEOUT_MS = 3e5;
+var COMPACTION_SEGMENT_TRIGGER = 8;
+var IDLE_MERGE_DELAY_MS = 1e3;
+var LIVE_TAIL_FREEZE_FLOOR = MIN_DOCUMENTS_FOR_SEGMENTS;
+var LIVE_TAIL_FLUSH_DOCUMENTS = 5e3;
+var MAX_PENDING_REPLICATION_DOCUMENTS = 2e4;
+var REPLICATION_WINDOW = 32;
+var LOAD_BUFFER_YIELD_INTERVAL = 1e3;
+var MAIN_COPY_LONE_QUERY_DOCUMENTS = 5e4;
+var POOL_RESTART_DELAY_MS = 1e3;
+var POOL_RESTART_DELAY_MAX_MS = 6e4;
+
 // src/engine/orchestration/eligibility.ts
 function toError3(value) {
   return value instanceof Error ? value : new Error(String(value));
@@ -5309,7 +5439,7 @@ function workerIneligibility(indexName, config, bootstrapModule) {
 function reportIneligible(state, indexName, error) {
   if (state.reportedIneligible.has(indexName)) return;
   state.reportedIneligible.add(indexName);
-  state.callbacks?.onPromotionFailure?.("index-excluded", error, false);
+  state.callbacks?.onCopyLoadFailure?.("index-excluded", error, false);
 }
 function eligibleIndexNames(state) {
   const names = [];
@@ -5323,33 +5453,26 @@ function eligibleIndexNames(state) {
   }
   return names;
 }
-function collectEligibleIndexes(state) {
-  const eligible = /* @__PURE__ */ new Map();
-  for (const name of eligibleIndexNames(state)) {
-    const manager = state.executor.getManager(name);
-    eligible.set(name, { documentCount: manager?.countDocuments() ?? 0 });
+
+// src/engine/orchestration/turn.ts
+function afterCurrentTurn(callback) {
+  if (typeof setImmediate === "function") {
+    setImmediate(callback);
+    return;
   }
-  return eligible;
+  setTimeout(callback, 0);
+}
+function yieldToEventLoop3() {
+  return new Promise((resolve) => afterCurrentTurn(resolve));
 }
 
 // src/engine/orchestration/replication.ts
-var MAX_PENDING_REPLICATION_DOCUMENTS = 2e4;
 async function dispatchToWorkers(state, action) {
   const pool = state.workerPool;
   if (!pool) return;
-  if (action.type === "createIndex") {
-    const ineligibility = workerIneligibility(action.indexName, action.config, state.bootstrapModule);
-    if (ineligibility) {
-      reportIneligible(state, action.indexName, ineligibility);
-      return;
-    }
-    pool.addIndexToAll(action.indexName);
-    state.promotedIndexes.add(action.indexName);
-  } else if ("indexName" in action && !state.promotedIndexes.has(action.indexName)) {
-    return;
-  }
-  const allExecutors = pool.getAllExecutors();
-  const results = await Promise.allSettled(allExecutors.map((workerExecutor) => workerExecutor.execute(action)));
+  const executors = "indexName" in action ? pool.executorsHolding(action.indexName) : pool.getAllExecutors();
+  if ("indexName" in action && !state.scaledOutIndexes.has(action.indexName)) return;
+  const results = await Promise.allSettled(executors.map((workerExecutor) => workerExecutor.execute(action)));
   for (const result of results) {
     if (result.status === "rejected") {
       if (action.type === "insert" && alreadyPresentOnWorker(result.reason)) {
@@ -5417,6 +5540,13 @@ function recordSegmentBroadcast(state, action) {
     }
     return;
   }
+  if (action.type === "freezeLiveTail") {
+    partitionLedger(state, action.indexName, action.partitionId).push({
+      segmentId: action.snapshot.segmentId,
+      documentCount: action.snapshot.documentCount
+    });
+    return;
+  }
   if (action.type === "swapSegments") {
     const entries = partitionLedger(state, action.indexName, action.partitionId);
     const dropped = new Set(action.dropSegmentIds);
@@ -5429,117 +5559,200 @@ function recordSegmentBroadcast(state, action) {
 function queueFor(state, indexName) {
   let queue = state.replicationQueues.get(indexName);
   if (queue === void 0) {
-    queue = { tail: Promise.resolve(), pendingActions: 0, pendingDocuments: 0 };
+    queue = { tail: Promise.resolve(), inFlight: [], pendingActions: 0, pendingDocuments: 0, drainWaiters: [] };
     state.replicationQueues.set(indexName, queue);
   }
   return queue;
 }
-function enqueue(state, indexName, action, weight) {
+function dispatchGate(queue) {
+  if (queue.inFlight.length < REPLICATION_WINDOW) return Promise.resolve();
+  return queue.inFlight[queue.inFlight.length - REPLICATION_WINDOW];
+}
+function enqueueReplication(state, indexName, action) {
+  const weight = documentWeight(action);
+  recordSegmentBroadcast(state, action);
   const queue = queueFor(state, indexName);
   queue.pendingActions += 1;
   queue.pendingDocuments += weight;
-  queue.tail = queue.tail.then(async () => {
+  const run = dispatchGate(queue).then(async () => {
     try {
       await dispatchToWorkers(state, action);
     } catch (err) {
       console.warn("Worker replication failed:", err);
     } finally {
+      const at = queue.inFlight.indexOf(run);
+      if (at !== -1) queue.inFlight.splice(at, 1);
       queue.pendingActions -= 1;
       queue.pendingDocuments -= weight;
+      if (queue.pendingDocuments < MAX_PENDING_REPLICATION_DOCUMENTS && queue.drainWaiters.length > 0) {
+        for (const resume of queue.drainWaiters.splice(0)) resume();
+      }
       if (queue.pendingActions === 0 && state.replicationQueues.get(indexName) === queue) {
         state.replicationQueues.delete(indexName);
       }
     }
   });
+  queue.inFlight.push(run);
+  queue.tail = run;
 }
 async function replicateToWorkers(state, action) {
-  if (state.promotionInProgress) {
-    state.promotionBuffer.push(detachCallerDocuments(action));
+  if (!("indexName" in action)) {
+    if (state.workerPool === null) return;
+    await awaitReplicationIdle(state);
+    await dispatchToWorkers(state, action);
     return;
   }
-  if (state.workerPool === null) return;
   const detached = detachCallerDocuments(action);
-  if (!("indexName" in detached)) {
-    await awaitReplicationIdle(state);
-    await dispatchToWorkers(state, detached);
+  const loading = state.copyLoadBuffers.get(action.indexName);
+  if (loading !== void 0) {
+    queueForCopies(state, detached);
+    if (loading.length % LOAD_BUFFER_YIELD_INTERVAL === 0) await yieldToEventLoop3();
     return;
   }
-  const weight = documentWeight(detached);
-  const queue = state.replicationQueues.get(detached.indexName);
-  if (queue !== void 0 && queue.pendingDocuments + weight > MAX_PENDING_REPLICATION_DOCUMENTS) {
-    await queue.tail;
+  const queue = state.replicationQueues.get(action.indexName);
+  if (queue !== void 0 && queue.pendingDocuments + documentWeight(detached) > MAX_PENDING_REPLICATION_DOCUMENTS) {
+    await new Promise((resume) => queue.drainWaiters.push(resume));
+  }
+  queueForCopies(state, detached);
+}
+function queueForCopies(state, action) {
+  if (!("indexName" in action)) return;
+  const loading = state.copyLoadBuffers.get(action.indexName);
+  if (loading !== void 0) {
+    loading.push(action);
+    return;
   }
-  recordSegmentBroadcast(state, detached);
-  enqueue(state, detached.indexName, detached, weight);
+  if (state.workerPool === null || !state.scaledOutIndexes.has(action.indexName)) return;
+  enqueueReplication(state, action.indexName, action);
+}
+function settled(queue) {
+  return Promise.all([...queue.inFlight, queue.tail]).then(() => void 0);
 }
 async function awaitReplicationIdle(state, indexName) {
   if (indexName !== void 0) {
     const queue = state.replicationQueues.get(indexName);
-    if (queue !== void 0) await queue.tail;
+    if (queue !== void 0) await settled(queue);
     return;
   }
   while (state.replicationQueues.size > 0) {
-    const tails = Array.from(state.replicationQueues.values(), (queue) => queue.tail);
-    await Promise.all(tails);
+    await Promise.all(Array.from(state.replicationQueues.values(), settled));
   }
 }
-async function drainPromotionBuffer(state) {
-  while (state.promotionBuffer.length > 0) {
-    const action = state.promotionBuffer.shift();
-    if (action === void 0) return;
-    await dispatchToWorkers(state, action);
+async function awaitWritesApplied(state, indexName) {
+  let awaitedTransition;
+  let awaitedRepair = null;
+  for (; ; ) {
+    const transition = state.copyTransitions.get(indexName);
+    if (transition !== void 0 && transition !== awaitedTransition) {
+      awaitedTransition = transition;
+      await transition.done;
+      continue;
+    }
+    const repair = state.poolRepair;
+    if (repair !== null && repair !== awaitedRepair) {
+      awaitedRepair = repair;
+      await repair;
+      continue;
+    }
+    await awaitReplicationIdle(state, indexName);
+    return;
+  }
+}
+
+// src/engine/orchestration/live-tail.ts
+function liveTailCount(manager, partitionId) {
+  if (partitionId >= manager.partitionCount) return 0;
+  const partition = manager.getPartition(partitionId);
+  return isCompositePartition(partition) ? partition.live.count() : partition.count();
+}
+function freezeTail(state, indexName, manager, partitionId) {
+  const segment = manager.freezeLiveTail(partitionId, (payload, documents) => {
+    const snapshot = freezeSegmentShared(payload, documents);
+    return snapshot === null ? null : createSharedFrozenSegment(snapshot);
+  });
+  if (segment === null || segment.sharedSnapshot === null) return;
+  queueForCopies(state, {
+    type: "freezeLiveTail",
+    indexName,
+    partitionId,
+    snapshot: segment.sharedSnapshot,
+    requestId: createRequestId()
+  });
+}
+function freezeLiveTail(state, indexName, manager, partitionId, floor) {
+  if (!state.scaledOutIndexes.has(indexName)) return;
+  if (liveTailCount(manager, partitionId) < floor) return;
+  try {
+    freezeTail(state, indexName, manager, partitionId);
+  } catch (err) {
+    console.warn(`Freezing the live tail of partition ${partitionId} of "${indexName}" failed:`, err);
+  }
+}
+function flushGrownTails(state, indexName) {
+  const manager = state.executor.getManager(indexName);
+  if (manager === void 0) return;
+  for (let partitionId = 0; partitionId < manager.partitionCount; partitionId++) {
+    freezeLiveTail(state, indexName, manager, partitionId, LIVE_TAIL_FLUSH_DOCUMENTS);
   }
 }
 
 // src/engine/orchestration/compaction.ts
-var COMPACTION_SEGMENT_TRIGGER = 8;
 function smallestSegmentIds(entries) {
   return [...entries].sort((a, b) => a.documentCount - b.documentCount).slice(0, COMPACTION_SEGMENT_TRIGGER).map((entry) => entry.segmentId);
 }
+function pickSegmentIds(entries, policy) {
+  if (policy === "idle") {
+    return entries.length >= 2 ? entries.map((entry) => entry.segmentId) : null;
+  }
+  return entries.length >= COMPACTION_SEGMENT_TRIGGER ? smallestSegmentIds(entries) : null;
+}
 function mainCompositeOf(manager, partitionId) {
   if (partitionId >= manager.partitionCount) return null;
   const partition = manager.getPartition(partitionId);
   return isCompositePartition(partition) ? partition : null;
 }
-function candidateSegmentIds(state, indexName, manager, partitionId) {
+function candidateSegmentIds(state, indexName, manager, partitionId, policy) {
   const composite = mainCompositeOf(manager, partitionId);
   if (composite !== null) {
     const sizes = composite.frozenSegmentSizes();
-    if (sizes.length >= COMPACTION_SEGMENT_TRIGGER) {
-      return smallestSegmentIds(
-        sizes.map((size) => ({ segmentId: size.segmentId, documentCount: size.liveDocumentCount }))
-      );
-    }
+    const picks = pickSegmentIds(
+      sizes.map((size) => ({ segmentId: size.segmentId, documentCount: size.liveDocumentCount })),
+      policy
+    );
+    if (picks !== null) return picks;
   }
   const ledger = state.segmentLedger.get(indexName)?.get(partitionId);
-  if (ledger !== void 0 && ledger.length >= COMPACTION_SEGMENT_TRIGGER) {
-    return smallestSegmentIds(ledger);
-  }
-  return null;
+  return ledger === void 0 ? null : pickSegmentIds(ledger, policy);
 }
 function mainHoldsAll(composite, segmentIds) {
   if (composite === null) return false;
   const held = new Set(composite.frozenSegmentSizes().map((size) => size.segmentId));
   return segmentIds.every((segmentId) => held.has(segmentId));
 }
-async function compactPartitionSegments2(state, indexName, manager, partitionId, segmentIds) {
-  await awaitReplicationIdle(state, indexName);
-  let snapshot = null;
+async function compactOnWorker(state, indexName, partitionId, segmentIds) {
   const pool = state.workerPool;
-  const executors = pool !== null && state.promotedIndexes.has(indexName) ? pool.getAllExecutors() : [];
-  if (executors.length > 0) {
-    try {
-      snapshot = await executors[0].execute({
-        type: "compactSegments",
-        indexName,
-        partitionId,
-        segmentIds: [...segmentIds],
-        requestId: createRequestId()
-      });
-    } catch (err) {
-      console.warn("Worker segment compaction failed, compacting on the main thread:", err);
-    }
+  if (pool === null || !state.scaledOutIndexes.has(indexName)) return null;
+  const lease = pool.leaseLeastBusy();
+  if (lease === null) return null;
+  try {
+    return await lease.executor.execute({
+      type: "compactSegments",
+      indexName,
+      partitionId,
+      segmentIds: [...segmentIds],
+      requestId: createRequestId()
+    });
+  } catch (err) {
+    console.warn("Worker segment compaction failed, compacting on the main thread:", err);
+    return null;
+  } finally {
+    lease.release();
   }
+}
+async function compactPartitionSegments2(state, indexName, manager, partitionId, segmentIds, policy) {
+  await awaitReplicationIdle(state, indexName);
+  if (policy === "idle" && !state.scaledOutIndexes.has(indexName)) return false;
+  let snapshot = await compactOnWorker(state, indexName, partitionId, segmentIds);
   const composite = mainCompositeOf(manager, partitionId);
   const holdsAll = mainHoldsAll(composite, segmentIds);
   let replacement = null;
@@ -5566,30 +5779,52 @@ async function compactPartitionSegments2(state, indexName, manager, partitionId,
   }
   return true;
 }
-async function compactIndexSegments(state, indexName) {
+async function compactIndexSegments(state, indexName, policy) {
   const manager = state.executor.getManager(indexName);
   if (!manager) return;
   const partitionIds = /* @__PURE__ */ new Set();
   for (let partitionId = 0; partitionId < manager.partitionCount; partitionId++) partitionIds.add(partitionId);
   for (const partitionId of state.segmentLedger.get(indexName)?.keys() ?? []) partitionIds.add(partitionId);
   for (const partitionId of partitionIds) {
-    let picks = candidateSegmentIds(state, indexName, manager, partitionId);
+    if (policy === "idle") {
+      await awaitReplicationIdle(state, indexName);
+      freezeLiveTail(state, indexName, manager, partitionId, LIVE_TAIL_FREEZE_FLOOR);
+    }
+    let picks = candidateSegmentIds(state, indexName, manager, partitionId, policy);
     while (picks !== null) {
-      const compacted = await compactPartitionSegments2(state, indexName, manager, partitionId, picks);
+      const compacted = await compactPartitionSegments2(state, indexName, manager, partitionId, picks, policy);
       if (!compacted) break;
-      picks = candidateSegmentIds(state, indexName, manager, partitionId);
+      picks = candidateSegmentIds(state, indexName, manager, partitionId, policy);
     }
   }
 }
-function maybeCompactSegments(state, indexName) {
-  if (state.compactionsInFlight.has(indexName)) return;
-  const run = compactIndexSegments(state, indexName).catch((err) => {
+function maybeCompactSegments(state, indexName, policy = "ingest") {
+  if (state.compactionsInFlight.has(indexName)) {
+    if (policy === "idle") scheduleIdleMerge(state, indexName);
+    return;
+  }
+  const run = compactIndexSegments(state, indexName, policy).catch((err) => {
     console.warn("Segment compaction failed:", err);
   }).finally(() => {
     state.compactionsInFlight.delete(indexName);
   });
   state.compactionsInFlight.set(indexName, run);
 }
+function scheduleIdleMerge(state, indexName) {
+  cancelIdleMerge(state, indexName);
+  const timer = setTimeout(() => {
+    state.idleMergeTimers.delete(indexName);
+    maybeCompactSegments(state, indexName, "idle");
+  }, IDLE_MERGE_DELAY_MS);
+  if (typeof timer.unref === "function") timer.unref();
+  state.idleMergeTimers.set(indexName, timer);
+}
+function cancelIdleMerge(state, indexName) {
+  const timer = state.idleMergeTimers.get(indexName);
+  if (timer === void 0) return;
+  clearTimeout(timer);
+  state.idleMergeTimers.delete(indexName);
+}
 async function awaitCompactions(state) {
   while (state.compactionsInFlight.size > 0) {
     await Promise.all([...state.compactionsInFlight.values()]);
@@ -5597,10 +5832,6 @@ async function awaitCompactions(state) {
 }
 
 // src/workers/worker-executor.ts
-var DEFAULT_BACKPRESSURE_LIMIT = 100;
-var DEFAULT_REQUEST_TIMEOUT = 3e4;
-var SHUTDOWN_TIMEOUT = 5e3;
-var CONSECUTIVE_TIMEOUTS_BEFORE_DEATH = 3;
 function errorFromEventLike(event) {
   if (event instanceof Error) {
     return event;
@@ -5618,7 +5849,7 @@ function errorFromEventLike(event) {
 }
 function createWorkerExecutor(worker, config) {
   const backpressureLimit = config?.backpressureLimit ?? DEFAULT_BACKPRESSURE_LIMIT;
-  const requestTimeout = config?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+  const requestTimeout = config?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const pending = /* @__PURE__ */ new Map();
   let deathError = null;
   let shutdownRequested = false;
@@ -5667,7 +5898,7 @@ function createWorkerExecutor(worker, config) {
     });
     worker.addEventListener("error", (event) => handleDeath(errorFromEventLike(event)));
   }
-  function execute(action) {
+  function execute(action, transfer) {
     if (deathError !== null) {
       return Promise.reject(deathError);
     }
@@ -5692,7 +5923,8 @@ function createWorkerExecutor(worker, config) {
         reject,
         timeoutId
       });
-      worker.postMessage(taggedAction);
+      if (transfer === void 0) worker.postMessage(taggedAction);
+      else worker.postMessage(taggedAction, transfer);
     });
   }
   async function shutdown() {
@@ -5706,7 +5938,7 @@ function createWorkerExecutor(worker, config) {
       const timeoutId = setTimeout(() => {
         pending.delete(requestId);
         reject(new NarsilError(ErrorCodes.WORKER_TIMEOUT, "Shutdown timed out"));
-      }, SHUTDOWN_TIMEOUT);
+      }, SHUTDOWN_TIMEOUT_MS);
       pending.set(requestId, {
         resolve: () => resolve(),
         reject,
@@ -5741,8 +5973,11 @@ async function createWorkerFactory(entryPoint) {
   const resolvedEntry = resolveEntryPoint();
   if (runtime.supportsWorkerThreads) {
     const workerThreadsModule = await import('worker_threads');
-    return function nodeFactory(_workerId, onDeath) {
-      const instance = new workerThreadsModule.Worker(new URL(resolvedEntry));
+    return function nodeFactory(workerId, onDeath) {
+      const instance = new workerThreadsModule.Worker(new URL(resolvedEntry), {
+        resourceLimits: WORKER_RESOURCE_LIMITS,
+        workerData: { workerId }
+      });
       return createWorkerExecutor(instance, { onDeath });
     };
   }
@@ -5755,136 +5990,441 @@ async function createWorkerFactory(entryPoint) {
   throw new NarsilError(ErrorCodes.WORKER_CRASHED, `No worker support available on runtime "${runtime.runtime}"`);
 }
 
-// src/engine/orchestration/promotion.ts
-async function bootstrapWorkers(state, pool, indexNames) {
-  const allExecutors = pool.getAllExecutors();
-  if (state.bootstrapModule !== void 0) {
-    const moduleUrl = state.bootstrapModule;
-    await Promise.all(
-      allExecutors.map(
-        (workerExecutor) => workerExecutor.execute({ type: "bootstrap", moduleUrl, requestId: "promote-bootstrap" })
-      )
-    );
-  }
-  for (const name of indexNames) {
-    const entry = state.indexRegistry.get(name);
-    if (!entry) continue;
-    await Promise.all(
-      allExecutors.map(
-        (workerExecutor) => workerExecutor.execute({
-          type: "createIndex",
-          indexName: name,
-          config: entry.config,
-          requestId: `promote-create-${name}`
-        })
-      )
-    );
-    const manager = state.executor.getManager(name);
-    if (!manager) continue;
-    for (let partitionId = 0; partitionId < manager.partitionCount; partitionId++) {
-      const serialized = manager.serializePartition(partitionId);
-      await Promise.all(
-        allExecutors.map(
-          (workerExecutor) => workerExecutor.execute({
-            type: "deserialize",
-            indexName: name,
-            partitionId,
-            data: serialized,
-            requestId: `promote-sync-${name}-${partitionId}`
-          })
-        )
-      );
+// src/engine/orchestration/vector-copies.ts
+function holdsIndex(state, indexName) {
+  return state.scaledOutIndexes.has(indexName) || state.copyLoadBuffers.has(indexName);
+}
+function sharedCopyHostOf(state) {
+  return {
+    get scratchSlotCount() {
+      return state.workerPool?.workerCount ?? state.keywordWorkerCount;
+    },
+    holdsIndex: (indexName) => holdsIndex(state, indexName),
+    resolvePartition: (indexName, docId) => state.executor.getManager(indexName)?.partitionIdOf(docId),
+    async loadShared(indexName, fieldName, handle, copy) {
+      if (!holdsIndex(state, indexName)) return false;
+      await replicateToWorkers(state, {
+        type: "loadVectorCopy",
+        indexName,
+        fieldName,
+        handle,
+        copy,
+        requestId: createRequestId()
+      });
+      await awaitWritesApplied(state, indexName);
+      return state.scaledOutIndexes.has(indexName);
+    },
+    async drop(indexName, fieldName, handle) {
+      if (!holdsIndex(state, indexName)) return;
+      await replicateToWorkers(state, {
+        type: "dropVectorCopy",
+        indexName,
+        fieldName,
+        handle,
+        requestId: createRequestId()
+      });
     }
-  }
+  };
 }
-async function runPromotion(state, reason) {
-  try {
-    const promotable = eligibleIndexNames(state);
-    if (promotable.length === 0) {
-      state.promotionBuffer.length = 0;
-      return;
+function refreshVectorCopies(state, indexName) {
+  if (state.vectorCopyPolicy?.host === void 0) return;
+  const manager = state.executor.getManager(indexName);
+  if (manager === void 0) return;
+  for (const vectorIndex of manager.getVectorIndexes().values()) vectorIndex.refreshWorkerCopies();
+}
+
+// src/engine/orchestration/request-threads.ts
+async function announceRequestThreads(state, pool) {
+  const listener = state.requestThreads;
+  if (listener === null) return;
+  for (const { workerId, executor } of pool.executorEntries()) {
+    await listener.onWorkerReady(workerId, executor);
+  }
+}
+function scheduleRequestThreadPoolRestart(state) {
+  if (state.requestThreads === null) return;
+  const timer = setTimeout(
+    () => {
+      if (state.requestThreads === null || state.workerPool !== null) return;
+      void ensurePool(state).then(() => scaleOutReadyIndexes(state)).catch((err) => {
+        console.warn("Restarting the request threads failed:", err);
+        scheduleRequestThreadPoolRestart(state);
+      });
+    },
+    Math.max(0, state.poolRetryAt - Date.now())
+  );
+  if (typeof timer.unref === "function") timer.unref();
+}
+async function serveRequestsOnWorkers(state, listener) {
+  state.requestThreads = listener;
+  state.keywordWorkerCount = resolveRequestThreadCount(state.config?.workers?.count);
+  if (state.vectorCopyPolicy !== void 0) {
+    state.vectorCopyPolicy.host = sharedCopyHostOf(state);
+    state.vectorCopyPolicy.enabled = state.workersEnabled;
+  }
+  if (state.poolStart !== null) await state.poolStart.catch(() => void 0);
+  const running = state.workerPool;
+  if (running !== null && running.workerCount !== state.keywordWorkerCount) {
+    retirePool(state, running);
+    state.poolRetryAt = 0;
+  }
+  const pool = await ensurePool(state);
+  for (const indexName of state.indexRegistry.keys()) {
+    refreshVectorCopies(state, indexName);
+    if (indexReadyForCopies(state, indexName)) {
+      await scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
     }
-    const factory = await createWorkerFactory();
-    const pool = createWorkerPool({
-      count: state.config?.workers?.count,
-      workerFactory: factory,
-      onWorkerCrash(workerId, indexNames, error) {
-        state.callbacks?.onWorkerCrash?.(workerId, indexNames, error);
-      }
-    });
-    for (const name of promotable) {
-      pool.addIndexToAll(name);
-    }
-    await bootstrapWorkers(state, pool, promotable);
-    state.workerPool = pool;
-    for (const name of promotable) {
-      state.promotedIndexes.add(name);
-      state.awaitingBufferedWrites.add(name);
-    }
-    state.promoter.markPromoted();
-    await drainPromotionBuffer(state);
-    state.awaitingBufferedWrites.clear();
-    state.callbacks?.onPromotion?.(pool.workerCount, reason);
-  } catch (err) {
-    state.promotionBuffer.length = 0;
-    throw err;
-  } finally {
-    state.awaitingBufferedWrites.clear();
-    state.promotionInProgress = false;
   }
+  return pool.workerCount;
 }
-async function promoteBeforeBatch(state, indexName, incomingCount) {
-  if (!state.workersEnabled || state.promotionBlocked || state.workerPool || incomingCount <= 0) return;
-  if (state.promotionInProgress) {
-    if (state.promotionRun) await state.promotionRun;
+function requestThreadCountOf(state) {
+  return resolveRequestThreadCount(state.config?.workers?.count);
+}
+function stopRequestThreads(state) {
+  const listener = state.requestThreads;
+  if (listener === null) return;
+  state.requestThreads = null;
+  const pool = state.workerPool;
+  if (pool === null) return;
+  for (const { workerId } of pool.executorEntries()) listener.onWorkerGone(workerId);
+}
+
+// src/engine/orchestration/repair.ts
+var COPY_RESTART_REASON = "A request arrived after every worker crashed and the restart delay passed";
+function nextRestartDelay(state) {
+  const delay2 = state.poolRetryDelayMs;
+  state.poolRetryDelayMs = Math.min(delay2 * 2, POOL_RESTART_DELAY_MAX_MS);
+  return delay2;
+}
+function deferPoolRestart(state) {
+  state.poolRetryAt = Date.now() + nextRestartDelay(state);
+}
+function retirePool(state, pool) {
+  if (state.workerPool !== pool) return;
+  state.workerPool = null;
+  cancelRepair(state);
+  deferPoolRestart(state);
+  for (const indexName of state.scaledOutIndexes) state.droppedCopies.set(indexName, COPY_RESTART_REASON);
+  state.scaledOutIndexes.clear();
+  state.segmentLedger.clear();
+  for (const { workerId } of pool.executorEntries()) state.requestThreads?.onWorkerGone(workerId);
+  void pool.shutdown().catch(() => void 0);
+  scheduleRequestThreadPoolRestart(state);
+}
+function handleWorkerCrash(state, pool, workerId, indexNames, error) {
+  state.callbacks?.onWorkerCrash?.(workerId, indexNames, error);
+  state.requestThreads?.onWorkerGone(workerId);
+  if (pool.getAllExecutors().length === 0) {
+    retirePool(state, pool);
     return;
   }
-  if (state.callbacks?.shouldDeferPromotion?.()) return;
-  const indexMap = collectEligibleIndexes(state);
-  const anticipated = indexMap.get(indexName);
-  if (anticipated === void 0) return;
-  anticipated.documentCount += incomingCount;
-  const result = state.promoter.check(indexMap);
-  if (!result.shouldPromote) return;
-  state.promotionInProgress = true;
-  const run = runPromotion(state, result.reason).catch((err) => {
-    const error = toError3(err);
-    state.promotionBlocked = isDeterministicFailure(error);
-    state.promotionInProgress = false;
-    state.callbacks?.onPromotionFailure?.(result.reason, error, !state.promotionBlocked);
-  });
-  const tracked = run.then(() => {
-    state.promotionRun = null;
-  });
-  state.promotionRun = tracked;
-  await tracked;
-}
-async function checkPromotion(state) {
-  if (!state.workersEnabled || state.promotionInProgress || state.promotionBlocked || state.workerPool) return;
-  if (state.callbacks?.shouldDeferPromotion?.()) return;
-  const indexMap = collectEligibleIndexes(state);
-  if (indexMap.size === 0) return;
-  const result = state.promoter.check(indexMap);
-  if (!result.shouldPromote) return;
-  state.promotionInProgress = true;
-  setTimeout(() => {
-    const run = runPromotion(state, result.reason).catch((err) => {
-      const error = toError3(err);
-      state.promotionBlocked = isDeterministicFailure(error);
-      state.promotionInProgress = false;
-      state.callbacks?.onPromotionFailure?.(result.reason, error, !state.promotionBlocked);
-    });
-    state.promotionRun = run.then(() => {
-      state.promotionRun = null;
-    });
-  }, 0);
+  scheduleRepair(state, pool);
+}
+function scheduleRepair(state, pool) {
+  if (state.workerPool !== pool || state.repairTimer !== null || state.poolRepair !== null) return;
+  const timer = setTimeout(() => {
+    state.repairTimer = null;
+    void repairPool(state, pool);
+  }, state.poolRetryDelayMs);
+  if (typeof timer.unref === "function") timer.unref();
+  state.repairTimer = timer;
+}
+function cancelRepair(state) {
+  if (state.repairTimer === null) return;
+  clearTimeout(state.repairTimer);
+  state.repairTimer = null;
+}
+async function loadOntoReplacement(state, replacement, indexName) {
+  const entry = state.indexRegistry.get(indexName);
+  const manager = state.executor.getManager(indexName);
+  if (entry === void 0 || manager === void 0 || !state.scaledOutIndexes.has(indexName)) return;
+  const buffered = [];
+  state.copyLoadBuffers.set(indexName, buffered);
+  try {
+    await loadIndexOntoWorkers(
+      indexName,
+      [replacement.executor],
+      entry.config,
+      manager,
+      void 0,
+      state.callbacks?.isAnalysisStale?.(indexName)
+    );
+    replacement.hold(indexName);
+  } finally {
+    state.copyLoadBuffers.delete(indexName);
+    for (const action of buffered) enqueueReplication(state, indexName, action);
+  }
+  refreshVectorCopies(state, indexName);
+}
+async function replaceWorker(state, pool, workerId) {
+  const replacement = pool.spawnReplacement(workerId);
+  if (replacement === null) return;
+  try {
+    if (state.bootstrapModule !== void 0) {
+      await replacement.executor.execute({
+        type: "bootstrap",
+        moduleUrl: state.bootstrapModule,
+        requestId: createRequestId()
+      });
+    }
+    for (const indexName of [...state.scaledOutIndexes]) {
+      await loadOntoReplacement(state, replacement, indexName);
+    }
+    replacement.admit();
+    await state.requestThreads?.onWorkerReady(workerId, replacement.executor);
+  } catch (err) {
+    replacement.abandon();
+    throw err;
+  }
+}
+async function replaceDeadWorkers(state, pool) {
+  for (const workerId of pool.deadWorkerIds()) {
+    if (state.workerPool !== pool) return;
+    await replaceWorker(state, pool, workerId);
+  }
+  state.poolRetryDelayMs = POOL_RESTART_DELAY_MS;
+}
+function repairPool(state, pool) {
+  if (state.workerPool !== pool) return Promise.resolve();
+  if (state.poolRepair !== null) return state.poolRepair;
+  const run = replaceDeadWorkers(state, pool).catch((err) => {
+    nextRestartDelay(state);
+    console.warn("Replacing a crashed worker failed:", err);
+  }).finally(() => {
+    state.poolRepair = null;
+    if (pool.deadWorkerIds().length > 0) scheduleRepair(state, pool);
+  });
+  state.poolRepair = run;
+  return run;
+}
+
+// src/engine/orchestration/scale-out.ts
+var COPY_RELOAD_REASON = "A request arrived after an idle spell dropped the worker copies";
+function copiesAllowed(state) {
+  if (!state.workersEnabled || state.scaleOutBlocked || state.shuttingDown) return false;
+  return state.workerPool !== null || Date.now() >= state.poolRetryAt;
+}
+async function startPool(state) {
+  eligibleIndexNames(state);
+  const factory = await createWorkerFactory();
+  let started = null;
+  const pool = createWorkerPool({
+    count: state.keywordWorkerCount,
+    workerFactory: factory,
+    onWorkerCrash(workerId, indexNames, error) {
+      if (started !== null) handleWorkerCrash(state, started, workerId, indexNames, error);
+    }
+  });
+  started = pool;
+  try {
+    pool.spawnAll();
+    if (state.bootstrapModule !== void 0) {
+      const moduleUrl = state.bootstrapModule;
+      await Promise.all(
+        pool.getAllExecutors().map(
+          (workerExecutor) => workerExecutor.execute({ type: "bootstrap", moduleUrl, requestId: "copies-bootstrap" })
+        )
+      );
+    }
+  } catch (err) {
+    await pool.shutdown().catch(() => void 0);
+    throw err;
+  }
+  return pool;
+}
+async function ensurePool(state) {
+  if (state.workerPool !== null) return state.workerPool;
+  if (state.poolStart === null) {
+    state.poolStart = startPool(state).then(
+      async (pool) => {
+        state.workerPool = pool;
+        state.poolStart = null;
+        try {
+          await announceRequestThreads(state, pool);
+        } catch (err) {
+          retirePool(state, pool);
+          throw err;
+        }
+        return pool;
+      },
+      (err) => {
+        state.poolStart = null;
+        deferPoolRestart(state);
+        throw err;
+      }
+    );
+  }
+  return state.poolStart;
+}
+function documentCountOf(state, indexName) {
+  return state.executor.getManager(indexName)?.countDocuments() ?? 0;
+}
+function copyThresholdReason(state, indexName) {
+  return `Index "${indexName}" holds ${documentCountOf(state, indexName)} documents, reaching the copy threshold of ${state.copyThreshold}`;
+}
+function indexReadyForCopies(state, indexName, incomingCount = 0) {
+  if (!copiesAllowed(state)) return false;
+  if (state.scaledOutIndexes.has(indexName) || state.desyncedIndexes.has(indexName)) return false;
+  if (state.copyTransitions.has(indexName)) return false;
+  if (state.callbacks?.shouldDeferCopies?.()) return false;
+  const entry = state.indexRegistry.get(indexName);
+  if (entry === void 0 || state.executor.getManager(indexName) === void 0) return false;
+  if (documentCountOf(state, indexName) + incomingCount < state.copyThreshold) return false;
+  const ineligibility = workerIneligibility(indexName, entry.config, state.bootstrapModule);
+  if (ineligibility !== null) {
+    reportIneligible(state, indexName, ineligibility);
+    return false;
+  }
+  return true;
+}
+async function loadCopies(state, indexName, reason) {
+  const entry = state.indexRegistry.get(indexName);
+  const manager = state.executor.getManager(indexName);
+  if (entry === void 0 || manager === void 0) return;
+  const ineligibility = workerIneligibility(indexName, entry.config, state.bootstrapModule);
+  if (ineligibility !== null) {
+    reportIneligible(state, indexName, ineligibility);
+    return;
+  }
+  const pool = await ensurePool(state);
+  if (state.executor.getManager(indexName) === void 0) return;
+  const dropReason = state.droppedCopies.get(indexName);
+  const reload = state.droppedCopies.delete(indexName);
+  const buffered = [];
+  state.copyLoadBuffers.set(indexName, buffered);
+  try {
+    await transferIndexToPool(indexName, pool, entry.config, manager, state.callbacks?.isAnalysisStale?.(indexName));
+    state.scaledOutIndexes.add(indexName);
+    state.lastAccessAt.set(indexName, Date.now());
+    state.poolRetryDelayMs = POOL_RESTART_DELAY_MS;
+    for (const action of buffered) enqueueReplication(state, indexName, action);
+  } catch (err) {
+    if (dropReason !== void 0) state.droppedCopies.set(indexName, dropReason);
+    throw err;
+  } finally {
+    state.copyLoadBuffers.delete(indexName);
+  }
+  if (reload) state.copyReloadCounts.set(indexName, (state.copyReloadCounts.get(indexName) ?? 0) + 1);
+  refreshVectorCopies(state, indexName);
+  scheduleIdleMerge(state, indexName);
+  state.callbacks?.onCopiesLoaded?.(pool.workerCount, reason);
+}
+async function loadAfter(previous, state, indexName, reason) {
+  if (previous !== void 0) await previous.done;
+  if (state.poolRepair !== null) await state.poolRepair;
+  if (!copiesAllowed(state)) return;
+  if (state.scaledOutIndexes.has(indexName) || state.desyncedIndexes.has(indexName)) return;
+  await loadCopies(state, indexName, reason);
+}
+function scaleOutIndex(state, indexName, reason) {
+  const previous = state.copyTransitions.get(indexName);
+  if (previous !== void 0 && previous.kind !== "drop") return previous.done;
+  const kind = state.droppedCopies.has(indexName) ? "reload" : "load";
+  const done = loadAfter(previous, state, indexName, reason).catch((err) => {
+    const error = toError3(err);
+    state.scaleOutBlocked = isDeterministicFailure(error);
+    state.callbacks?.onCopyLoadFailure?.(reason, error, !state.scaleOutBlocked);
+  }).finally(() => {
+    if (state.copyTransitions.get(indexName)?.done === done) state.copyTransitions.delete(indexName);
+  });
+  state.copyTransitions.set(indexName, { kind, done });
+  return done;
+}
+async function scaleOutReadyIndexes(state) {
+  if (!copiesAllowed(state)) return;
+  for (const indexName of state.indexRegistry.keys()) {
+    if (!indexReadyForCopies(state, indexName)) continue;
+    const reason = copyThresholdReason(state, indexName);
+    setTimeout(() => {
+      void scaleOutIndex(state, indexName, reason);
+    }, 0);
+  }
+}
+async function scaleOutBeforeBatch(state, indexName, incomingCount) {
+  if (incomingCount <= 0) return;
+  const pending = state.copyTransitions.get(indexName);
+  if (pending !== void 0) {
+    if (pending.kind === "load") await pending.done;
+    return;
+  }
+  if (!indexReadyForCopies(state, indexName, incomingCount)) return;
+  await scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
+}
+
+// src/engine/orchestration/idle.ts
+function isIndexBusy(state, indexName) {
+  return state.poolRepair !== null || state.copyTransitions.has(indexName) || state.replicationQueues.has(indexName) || state.compactionsInFlight.has(indexName);
+}
+function noteAccess(state, indexName) {
+  state.lastAccessAt.set(indexName, Date.now());
+  if (!copiesAllowed(state)) return;
+  const reloadReason = state.droppedCopies.get(indexName);
+  if (reloadReason !== void 0) {
+    const transition = state.copyTransitions.get(indexName);
+    if (transition !== void 0 && transition.kind !== "drop") return;
+    void scaleOutIndex(state, indexName, reloadReason);
+    return;
+  }
+  if (indexReadyForCopies(state, indexName)) {
+    void scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
+  }
+}
+async function releaseCopies(state, indexName) {
+  const pool = state.workerPool;
+  if (pool === null) return;
+  await awaitReplicationIdle(state, indexName);
+  const cutoff = Date.now() - state.copyIdleTimeoutMs;
+  if ((state.lastAccessAt.get(indexName) ?? Date.now()) > cutoff) return;
+  if (!state.scaledOutIndexes.has(indexName) || state.compactionsInFlight.has(indexName)) return;
+  state.scaledOutIndexes.delete(indexName);
+  state.droppedCopies.set(indexName, COPY_RELOAD_REASON);
+  cancelIdleMerge(state, indexName);
+  const outcomes = await Promise.allSettled(
+    pool.executorsHolding(indexName).map((worker) => worker.execute({ type: "dropIndex", indexName, requestId: `idle-drop-${indexName}` }))
+  );
+  for (const outcome of outcomes) {
+    if (outcome.status === "rejected") console.warn("Dropping an idle worker copy failed:", outcome.reason);
+  }
+  pool.removeIndex(indexName);
+  state.segmentLedger.delete(indexName);
+}
+async function dropIdleCopies(state, indexName) {
+  const previous = state.copyTransitions.get(indexName);
+  if (previous !== void 0) return;
+  const done = releaseCopies(state, indexName).catch((err) => {
+    console.warn("Dropping idle worker copies failed:", err);
+  }).finally(() => {
+    if (state.copyTransitions.get(indexName)?.done === done) state.copyTransitions.delete(indexName);
+  });
+  state.copyTransitions.set(indexName, { kind: "drop", done });
+  await done;
+}
+async function sweepIdleCopies(state) {
+  const cutoff = Date.now() - state.copyIdleTimeoutMs;
+  for (const indexName of [...state.scaledOutIndexes]) {
+    if ((state.lastAccessAt.get(indexName) ?? Date.now()) > cutoff) continue;
+    if (isIndexBusy(state, indexName)) continue;
+    await dropIdleCopies(state, indexName);
+  }
+}
+function startIdleSweep(state) {
+  if (!state.workersEnabled || state.idleSweep !== null) return;
+  const interval = Math.min(MAX_SWEEP_INTERVAL_MS, Math.max(MIN_SWEEP_INTERVAL_MS, state.copyIdleTimeoutMs / 2));
+  const timer = setInterval(() => void sweepIdleCopies(state).catch(() => void 0), interval);
+  if (typeof timer.unref === "function") timer.unref();
+  state.idleSweep = timer;
+}
+function stopIdleSweep(state) {
+  if (state.idleSweep === null) return;
+  clearInterval(state.idleSweep);
+  state.idleSweep = null;
 }
 
 // src/engine/orchestration/search.ts
-function partitionsPerWorker(totalPartitions, workerCount) {
-  const assignments = Array.from({ length: workerCount }, () => []);
-  for (let partitionId = 0; partitionId < totalPartitions; partitionId++) {
-    assignments[partitionId % workerCount].push(partitionId);
+function partitionsPerLease(scope, leaseCount) {
+  const assignments = Array.from({ length: leaseCount }, () => []);
+  for (let at = 0; at < scope.length; at++) {
+    assignments[at % leaseCount].push(scope[at]);
   }
   return assignments;
 }
@@ -5902,67 +6442,74 @@ function mergeWorkerResults(results) {
     facets: workerFacets.length > 0 ? mergeFacets(workerFacets) : void 0
   };
 }
+function scoresPerPartition(state, indexName, params, globalStats) {
+  const mode = params.scoring ?? state.indexRegistry.get(indexName)?.config.defaultScoring ?? "local";
+  if (mode === "local") return true;
+  return mode === "broadcast" && globalStats !== void 0;
+}
+function queryAction(indexName, params, globalStats, partitionIds) {
+  return {
+    type: "query",
+    indexName,
+    params,
+    requestId: createRequestId(),
+    ...partitionIds !== void 0 ? { partitionIds } : {},
+    ...globalStats !== void 0 ? { globalStats } : {}
+  };
+}
+async function runSplit(leases, scope, indexName, params, globalStats) {
+  const assignments = partitionsPerLease(scope, leases.length);
+  const results = await Promise.all(
+    assignments.map(
+      (partitionIds, at) => leases[at].executor.execute(queryAction(indexName, params, globalStats, partitionIds)).finally(() => leases[at].release())
+    )
+  );
+  return mergeWorkerResults(results);
+}
+function takeMainCopyTurn(state) {
+  if (state.mainCopyQueries === "none" || state.mainCopyTurnTaken) return false;
+  state.mainCopyTurnTaken = true;
+  afterCurrentTurn(() => {
+    state.mainCopyTurnTaken = false;
+  });
+  return true;
+}
+function answersFasterOnMainCopy(state, pool, manager) {
+  if (pool.queriesInFlight() > 0) return false;
+  if (manager.countDocuments() > MAIN_COPY_LONE_QUERY_DOCUMENTS) return false;
+  return takeMainCopyTurn(state);
+}
 async function searchViaWorker(state, indexName, params, globalStats, partitionIds) {
   const pool = state.workerPool;
   if (!pool) return null;
-  if (!state.promotedIndexes.has(indexName)) return null;
-  if (state.awaitingBufferedWrites.has(indexName)) return null;
-  const pendingReplication = state.replicationQueues.get(indexName);
-  if (pendingReplication !== void 0 && pendingReplication.pendingActions > 0) return null;
+  if (!state.scaledOutIndexes.has(indexName) || state.copyLoadBuffers.has(indexName)) return null;
   const manager = state.executor.getManager(indexName);
   if (!manager) return null;
-  const allExecutors = pool.getAllExecutors();
-  if (allExecutors.length === 0) return null;
-  const stats = globalStats !== void 0 ? { globalStats } : {};
-  if (allExecutors.length === 1) {
-    try {
-      return await allExecutors[0].execute({
-        type: "query",
-        indexName,
-        params,
-        requestId: createRequestId(),
-        ...partitionIds !== void 0 ? { partitionIds } : {},
-        ...stats
-      });
-    } catch (err) {
-      console.warn("Worker search failed, falling back to local:", err);
-      return null;
-    }
-  }
-  const assignments = partitionsPerWorker(manager.partitionCount, allExecutors.length);
-  const scopedAssignments = partitionIds === void 0 ? assignments : assignments.map((assigned) => assigned.filter((partitionId) => partitionIds.includes(partitionId)));
-  const activeAssignments = [];
-  for (let index = 0; index < allExecutors.length; index++) {
-    if (scopedAssignments[index].length > 0) {
-      activeAssignments.push({ executor: allExecutors[index], partitionIds: scopedAssignments[index] });
-    }
-  }
-  if (activeAssignments.length === 0) {
-    return { scored: [], totalMatched: 0 };
-  }
+  if (answersFasterOnMainCopy(state, pool, manager)) return null;
+  const scope = partitionIds ?? Array.from({ length: manager.partitionCount }, (_, partitionId) => partitionId);
+  const idle = pool.leaseIdle(scope.length);
+  const leases = [];
   try {
-    const results = await Promise.all(
-      activeAssignments.map(
-        (assignment) => assignment.executor.execute({
-          type: "query",
-          indexName,
-          params,
-          requestId: createRequestId(),
-          partitionIds: assignment.partitionIds,
-          ...stats
-        })
-      )
-    );
-    return mergeWorkerResults(results);
+    if (idle.length >= 2 && scoresPerPartition(state, indexName, params, globalStats)) {
+      leases.push(...idle);
+      return await runSplit(leases, scope, indexName, params, globalStats);
+    }
+    for (const lease2 of idle.slice(1)) lease2.release();
+    const lease = idle[0] ?? (takeMainCopyTurn(state) ? null : pool.leaseLeastBusy());
+    if (lease === null) return null;
+    leases.push(lease);
+    return await lease.executor.execute(queryAction(indexName, params, globalStats, partitionIds));
   } catch (err) {
-    console.warn("Parallel worker search failed, falling back to local:", err);
+    console.warn("Worker search failed, falling back to local:", err);
     return null;
+  } finally {
+    for (const lease of leases) lease.release();
   }
 }
 
 // src/engine/orchestration/segments.ts
 function segmentBuildConcurrency(state, indexName) {
-  if (!state.promotedIndexes.has(indexName)) return 0;
+  if (!state.scaledOutIndexes.has(indexName)) return 0;
   return state.workerPool?.workerCount ?? 0;
 }
 async function buildSegments(state, requests) {
@@ -5979,44 +6526,59 @@ async function buildSegments(state, requests) {
 }
 
 // src/engine/orchestration/index.ts
-function createWorkerOrchestrator(config, executor, promoter, indexRegistry, callbacks) {
+function workersEnabledByDefault() {
+  return detectRuntime().runtime !== "browser";
+}
+function copyIdleTimeoutBeforeClose(closeAfterMs) {
+  return closeAfterMs === void 0 ? DEFAULT_COPY_IDLE_TIMEOUT_MS : Math.min(DEFAULT_COPY_IDLE_TIMEOUT_MS, closeAfterMs);
+}
+function createWorkerOrchestrator(config, executor, indexRegistry, callbacks, vectorCopyPolicy) {
   const state = {
     config,
     executor,
-    promoter,
     indexRegistry,
     callbacks,
-    workersEnabled: config?.workers?.enabled === true,
+    vectorCopyPolicy,
+    workersEnabled: config?.workers?.enabled ?? workersEnabledByDefault(),
+    keywordWorkerCount: splitWorkerBudget(resolveWorkerCount(config?.workers?.count)).keyword,
+    requestThreads: null,
+    copyThreshold: config?.workers?.promotionThreshold ?? DEFAULT_COPY_THRESHOLD,
+    copyIdleTimeoutMs: config?.workers?.idleTimeoutMs ?? copyIdleTimeoutBeforeClose(config?.lifecycle?.idleTimeoutMs),
     bootstrapModule: config?.workers?.bootstrapModule,
-    promotionBuffer: [],
-    awaitingBufferedWrites: /* @__PURE__ */ new Set(),
     reportedIneligible: /* @__PURE__ */ new Set(),
-    promotedIndexes: /* @__PURE__ */ new Set(),
+    scaledOutIndexes: /* @__PURE__ */ new Set(),
+    desyncedIndexes: /* @__PURE__ */ new Set(),
+    copyLoadBuffers: /* @__PURE__ */ new Map(),
+    copyTransitions: /* @__PURE__ */ new Map(),
+    droppedCopies: /* @__PURE__ */ new Map(),
+    lastAccessAt: /* @__PURE__ */ new Map(),
+    copyReloadCounts: /* @__PURE__ */ new Map(),
     replicationQueues: /* @__PURE__ */ new Map(),
     segmentLedger: /* @__PURE__ */ new Map(),
     compactionsInFlight: /* @__PURE__ */ new Map(),
+    idleMergeTimers: /* @__PURE__ */ new Map(),
     workerPool: null,
-    promotionInProgress: false,
-    promotionBlocked: false,
-    promotionRun: null
+    poolStart: null,
+    poolRetryAt: 0,
+    poolRetryDelayMs: POOL_RESTART_DELAY_MS,
+    poolRepair: null,
+    mainCopyTurnTaken: false,
+    mainCopyQueries: config?.workers?.mainCopyQueries,
+    repairTimer: null,
+    scaleOutBlocked: false,
+    shuttingDown: false,
+    idleSweep: null
   };
-  async function resyncIndex(indexName, wasPromoted) {
-    if (state.promotionRun) {
-      await state.promotionRun.catch(() => void 0);
-    }
-    const pool = state.workerPool;
-    if (!pool) return;
-    if (!wasPromoted && !state.promotedIndexes.has(indexName)) return;
-    const entry = indexRegistry.get(indexName);
-    if (!entry) return;
-    if (workerIneligibility(indexName, entry.config, state.bootstrapModule)) return;
-    const manager = executor.getManager(indexName);
-    if (!manager) return;
-    state.promotedIndexes.delete(indexName);
-    await awaitReplicationIdle(state, indexName);
-    state.segmentLedger.delete(indexName);
-    await transferIndexToPool(indexName, pool, entry.config, manager);
-    state.promotedIndexes.add(indexName);
+  startIdleSweep(state);
+  async function resyncIndex(indexName, wasScaledOut) {
+    state.desyncedIndexes.delete(indexName);
+    if (!wasScaledOut) return;
+    await scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
+  }
+  async function openIndex(indexName) {
+    state.droppedCopies.delete(indexName);
+    if (!indexReadyForCopies(state, indexName)) return;
+    await scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
   }
   async function getWorkerMemoryStats() {
     if (!state.workerPool) return [];
@@ -6025,91 +6587,140 @@ function createWorkerOrchestrator(config, executor, promoter, indexRegistry, cal
       workerId: report.workerId,
       heapUsed: report.heapUsed,
       heapTotal: report.heapTotal,
+      heapLimit: report.heapLimit,
       external: report.external
     }));
   }
+  function workerCopies() {
+    const reports = [];
+    for (const indexName of indexRegistry.keys()) {
+      reports.push({
+        indexName,
+        scaledOut: state.scaledOutIndexes.has(indexName),
+        reloadCount: state.copyReloadCounts.get(indexName) ?? 0
+      });
+    }
+    return reports;
+  }
   async function shutdown() {
+    state.shuttingDown = true;
+    stopIdleSweep(state);
+    cancelRepair(state);
+    stopRequestThreads(state);
+    for (const indexName of [...state.idleMergeTimers.keys()]) cancelIdleMerge(state, indexName);
+    await Promise.allSettled([...state.copyTransitions.values()].map((transition) => transition.done));
+    if (state.poolRepair !== null) await state.poolRepair;
+    if (state.poolStart !== null) await state.poolStart.catch(() => void 0);
     if (state.workerPool) {
       await awaitCompactions(state);
       await awaitReplicationIdle(state);
       await state.workerPool.shutdown();
       state.workerPool = null;
-      state.promotedIndexes.clear();
+      state.scaledOutIndexes.clear();
       state.replicationQueues.clear();
       state.segmentLedger.clear();
     }
   }
-  async function awaitPromotionIdle() {
-    while (state.promotionInProgress) {
-      const run = state.promotionRun;
-      if (run !== null) {
-        await run;
-      } else {
-        await new Promise((resolve) => setTimeout(resolve, 0));
+  async function restoreAfterFailedClose(indexName, failure) {
+    const pool = state.workerPool;
+    const entry = indexRegistry.get(indexName);
+    const manager = executor.getManager(indexName);
+    if (pool !== null && entry !== void 0 && manager !== void 0) {
+      try {
+        await transferIndexToPool(indexName, pool, entry.config, manager, callbacks?.isAnalysisStale?.(indexName));
+        state.scaledOutIndexes.add(indexName);
+        refreshVectorCopies(state, indexName);
+      } catch (repairError) {
+        throw new NarsilError(
+          ErrorCodes.WORKER_CRASHED,
+          `Worker copies for index "${indexName}" could not be restored after close failed`,
+          {
+            indexName,
+            closeError: failure.reason instanceof Error ? failure.reason.message : String(failure.reason),
+            repairError: repairError instanceof Error ? repairError.message : String(repairError)
+          }
+        );
       }
     }
+    if (failure.reason instanceof NarsilError) throw failure.reason;
+    throw new NarsilError(ErrorCodes.WORKER_CRASHED, `A worker could not close index "${indexName}"`, {
+      indexName,
+      cause: failure.reason instanceof Error ? failure.reason.message : String(failure.reason)
+    });
+  }
+  function withdrawCopies(indexName) {
+    const pool = state.workerPool;
+    if (pool === null) return;
+    const holders = pool.executorsHolding(indexName);
+    pool.removeIndex(indexName);
+    state.segmentLedger.delete(indexName);
+    void Promise.allSettled(
+      holders.map((worker) => worker.execute({ type: "dropIndex", indexName, requestId: `desync-drop-${indexName}` }))
+    );
   }
   async function closeIndex(indexName) {
-    await awaitPromotionIdle();
+    if (state.poolRepair !== null) await state.poolRepair;
+    const transition = state.copyTransitions.get(indexName);
+    if (transition !== void 0) await transition.done;
     await awaitReplicationIdle(state, indexName);
     await awaitCompactions(state);
+    cancelIdleMerge(state, indexName);
     const pool = state.workerPool;
-    if (pool !== null && state.promotedIndexes.has(indexName)) {
+    if (pool !== null && state.scaledOutIndexes.has(indexName)) {
+      state.scaledOutIndexes.delete(indexName);
       const outcomes = await Promise.allSettled(
-        pool.getAllExecutors().map((worker) => worker.execute({ type: "dropIndex", indexName, requestId: `close-${indexName}` }))
+        pool.executorsHolding(indexName).map((worker) => worker.execute({ type: "dropIndex", indexName, requestId: `close-${indexName}` }))
       );
       const failure = outcomes.find((outcome) => outcome.status === "rejected");
-      if (failure?.status === "rejected") {
-        const entry = indexRegistry.get(indexName);
-        const manager = executor.getManager(indexName);
-        if (entry !== void 0 && manager !== void 0) {
-          try {
-            await transferIndexToPool(indexName, pool, entry.config, manager);
-          } catch (repairError) {
-            throw new NarsilError(
-              ErrorCodes.WORKER_CRASHED,
-              `Worker copies for index "${indexName}" could not be restored after close failed`,
-              {
-                indexName,
-                closeError: failure.reason instanceof Error ? failure.reason.message : String(failure.reason),
-                repairError: repairError instanceof Error ? repairError.message : String(repairError)
-              }
-            );
-          }
-        }
-        if (failure.reason instanceof NarsilError) throw failure.reason;
-        throw new NarsilError(ErrorCodes.WORKER_CRASHED, `A worker could not close index "${indexName}"`, {
-          indexName,
-          cause: failure.reason instanceof Error ? failure.reason.message : String(failure.reason)
-        });
-      }
+      if (failure?.status === "rejected") await restoreAfterFailedClose(indexName, failure);
       pool.removeIndex(indexName);
     }
-    state.promotedIndexes.delete(indexName);
+    state.droppedCopies.delete(indexName);
+    state.desyncedIndexes.delete(indexName);
+    state.lastAccessAt.delete(indexName);
     state.replicationQueues.delete(indexName);
     state.segmentLedger.delete(indexName);
   }
   async function replicate(action) {
     await replicateToWorkers(state, action);
-    if (action.type === "attachSegments") {
-      maybeCompactSegments(state, action.indexName);
+    if (!("indexName" in action)) return;
+    if (action.type === "attachSegments") maybeCompactSegments(state, action.indexName);
+    if (action.type === "insert" || action.type === "update") flushGrownTails(state, action.indexName);
+    if (state.scaledOutIndexes.has(action.indexName) || state.copyLoadBuffers.has(action.indexName)) {
+      scheduleIdleMerge(state, action.indexName);
     }
   }
   return {
-    checkPromotion: () => checkPromotion(state),
-    promoteBeforeBatch: (indexName, incomingCount) => promoteBeforeBatch(state, indexName, incomingCount),
+    scaleOutReadyIndexes: () => scaleOutReadyIndexes(state),
+    scaleOutBeforeBatch: (indexName, incomingCount) => scaleOutBeforeBatch(state, indexName, incomingCount),
     replicateToWorkers: replicate,
     awaitReplication: (indexName) => awaitReplicationIdle(state, indexName),
+    awaitWrites: (indexName) => awaitWritesApplied(state, indexName),
     awaitCompactions: () => awaitCompactions(state),
-    openIndex: (indexName) => resyncIndex(indexName, true),
+    openIndex,
     closeIndex,
-    isIndexBusy: (indexName) => state.promotionInProgress || state.replicationQueues.has(indexName) || state.compactionsInFlight.has(indexName),
+    isIndexBusy: (indexName) => isIndexBusy(state, indexName),
     buildSegments: (requests) => buildSegments(state, requests),
     segmentBuildConcurrency: (indexName) => segmentBuildConcurrency(state, indexName),
     searchViaWorker: (indexName, params, globalStats, partitionIds) => searchViaWorker(state, indexName, params, globalStats, partitionIds),
-    isPromoted: () => state.workerPool !== null,
-    desyncIndex: (indexName) => state.promotedIndexes.delete(indexName),
+    hasWorkerPool: () => state.workerPool !== null,
+    mainCopyQueries: () => state.mainCopyQueries ?? "lone",
+    shareMainThread: () => {
+      if (state.mainCopyQueries === void 0) state.mainCopyQueries = "none";
+    },
+    serveRequestsOnWorkers: (listener) => serveRequestsOnWorkers(state, listener),
+    requestThreadCount: () => requestThreadCountOf(state),
+    copyIdleTimeoutMs: () => state.copyIdleTimeoutMs,
+    stopRequestThreads: () => stopRequestThreads(state),
+    desyncIndex: (indexName) => {
+      state.desyncedIndexes.add(indexName);
+      const wasScaledOut = state.scaledOutIndexes.delete(indexName);
+      if (wasScaledOut) withdrawCopies(indexName);
+      return wasScaledOut;
+    },
     resyncIndex,
+    noteAccess: (indexName) => noteAccess(state, indexName),
+    workerCopies,
     getWorkerMemoryStats,
     shutdown
   };
@@ -6120,47 +6731,15 @@ function getVectorFieldPaths(schema) {
   return new Set(extractVectorFieldsFromSchema(schema).keys());
 }
 
-// src/engine/watermark.ts
-function createWatermarkNotifier(deps) {
-  const latchedCapacity = /* @__PURE__ */ new Map();
-  function check(indexName) {
-    const partitionConfig = deps.getPartitionConfig(indexName);
-    const maxDocs = partitionConfig?.maxDocsPerPartition;
-    const watermark = partitionConfig?.watermark;
-    if (maxDocs === void 0 || watermark === void 0) {
-      latchedCapacity.delete(indexName);
-      return;
-    }
-    const manager = deps.getManager(indexName);
-    if (!manager) {
-      latchedCapacity.delete(indexName);
-      return;
-    }
-    const partitionCount = manager.partitionCount;
-    const capacity = maxDocs * partitionCount;
-    const documentCount = manager.countDocuments();
-    const threshold = watermark * capacity;
-    if (documentCount < threshold) {
-      latchedCapacity.delete(indexName);
-      return;
-    }
-    if (latchedCapacity.get(indexName) === capacity) return;
-    latchedCapacity.set(indexName, capacity);
-    deps.emit({ indexName, documentCount, capacity, partitionCount });
-  }
-  function forget(indexName) {
-    latchedCapacity.delete(indexName);
-  }
-  return { check, forget };
-}
-
 // src/engine/core.ts
 function createEngineCore(config, hooks) {
-  const executor = createDirectExecutor();
-  const promoter = createExecutionPromoter({
-    perIndexThreshold: config?.workers?.promotionThreshold,
-    totalThreshold: config?.workers?.totalPromotionThreshold
-  });
+  validateWorkerConfig(config?.workers, config?.lifecycle);
+  const vectorWorkerCount = splitWorkerBudget(resolveWorkerCount(config?.workers?.count)).vector;
+  const vectorCopyPolicy = {
+    enabled: (config?.workers?.enabled ?? workersEnabledByDefault()) && vectorWorkerCount > 0,
+    count: vectorWorkerCount
+  };
+  const executor = createDirectExecutor({ vectorWorkerCopies: vectorCopyPolicy });
   const pluginRegistry = createPluginRegistry();
   if (config?.plugins) {
     for (const plugin of config.plugins) pluginRegistry.register(plugin);
@@ -6178,36 +6757,38 @@ function createEngineCore(config, hooks) {
   const shutdownState = { isShutdown: false };
   const abortController = new AbortController();
   const rebalancingIndexes = /* @__PURE__ */ new Set();
-  const orchestrator = createWorkerOrchestrator(config, executor, promoter, indexRegistry, {
-    shouldDeferPromotion() {
-      return rebalancingIndexes.size > 0;
-    },
-    onPromotion(workerCount, reason) {
-      const handlers = eventHandlers.get("workerPromote");
-      if (handlers) {
-        for (const handler of handlers) handler({ workerCount, reason });
-      }
-      void Promise.resolve(pluginRegistry.runHook("onWorkerPromote", { workerCount, reason })).catch((err) => {
-        console.warn("onWorkerPromote plugin hook failed:", err instanceof Error ? err.message : String(err));
-      });
-    },
-    onPromotionFailure(reason, error, retryable) {
-      const handlers = eventHandlers.get("workerPromoteFailure");
-      if (!handlers || handlers.size === 0) {
-        console.warn(`Worker promotion failed (${reason}):`, error);
-        return;
+  const orchestrator = createWorkerOrchestrator(
+    config,
+    executor,
+    indexRegistry,
+    {
+      shouldDeferCopies() {
+        return rebalancingIndexes.size > 0;
+      },
+      isAnalysisStale(indexName) {
+        return analysisRebuild.isStale(indexName);
+      },
+      onCopiesLoaded(workerCount, reason) {
+        emitEngineEvent(eventHandlers, "workerPromote", { workerCount, reason });
+        void Promise.resolve(pluginRegistry.runHook("onWorkerPromote", { workerCount, reason })).catch(
+          (err) => {
+            console.warn("onWorkerPromote plugin hook failed:", err instanceof Error ? err.message : String(err));
+          }
+        );
+      },
+      onCopyLoadFailure(reason, error, retryable) {
+        if (emitEngineEvent(eventHandlers, "workerPromoteFailure", { reason, error, retryable }) === 0) {
+          console.warn(`Loading worker copies failed (${reason}):`, error);
+        }
+      },
+      onWorkerCrash(workerId, indexNames, error) {
+        if (emitEngineEvent(eventHandlers, "workerCrash", { workerId, indexNames, error }) === 0) {
+          console.warn(`Worker ${workerId} crashed:`, error);
+        }
       }
-      for (const handler of handlers) handler({ reason, error, retryable });
     },
-    onWorkerCrash(workerId, indexNames, error) {
-      const handlers = eventHandlers.get("workerCrash");
-      if (!handlers || handlers.size === 0) {
-        console.warn(`Worker ${workerId} crashed:`, error);
-        return;
-      }
-      for (const handler of handlers) handler({ workerId, indexNames, error });
-    }
-  });
+    vectorCopyPolicy
+  );
   const rebalancer = createRebalancer();
   const rebalanceRouter = createPartitionRouter();
   const waqMap = /* @__PURE__ */ new Map();
@@ -6316,10 +6897,7 @@ function createEngineCore(config, hooks) {
     indexRegistry,
     createIndexFromMetadata,
     emitFatalError(error) {
-      const handlers = eventHandlers.get("durabilityError");
-      if (handlers) {
-        for (const handler of handlers) handler({ error });
-      }
+      emitEngineEvent(eventHandlers, "durabilityError", { error });
     },
     publishCheckpointedPartitions: (indexName, partitions) => invalidation?.publishPartitions(indexName, partitions) ?? Promise.resolve(),
     recordCheckpoint(indexName, documentCount, partitionCount) {
@@ -6342,29 +6920,18 @@ function createEngineCore(config, hooks) {
     },
     reloadIndex: (indexName) => durability?.manager.reloadIndex?.(indexName) ?? Promise.resolve(),
     onError(error) {
-      const handlers = eventHandlers.get("invalidationError");
-      if (!handlers || handlers.size === 0) {
+      if (emitEngineEvent(eventHandlers, "invalidationError", { error }) === 0) {
         console.warn("Invalidation error:", error);
-        return;
-      }
-      for (const handler of handlers) handler({ error });
-    }
-  });
-  const watermarkNotifier = createWatermarkNotifier({
-    getManager: (indexName) => executor.getManager(indexName),
-    getPartitionConfig: (indexName) => indexRegistry.get(indexName)?.config.partitions,
-    emit(payload) {
-      const handlers = eventHandlers.get("partitionWatermark");
-      if (!handlers) return;
-      for (const handler of handlers) {
-        try {
-          handler(payload);
-        } catch (err) {
-          console.warn("partitionWatermark handler error:", err instanceof Error ? err.message : String(err));
-        }
       }
     }
   });
+  const notifierWiring = {
+    eventHandlers,
+    indexRegistry,
+    getManager: (indexName) => executor.getManager(indexName)
+  };
+  const watermarkNotifier = wireWatermarkNotifier(notifierWiring);
+  const heapPressureNotifier = wireHeapPressureNotifier(notifierWiring);
   const analysisRebuild = wireAnalysisRebuild({
     config: config?.analysis,
     eventHandlers,
@@ -6383,7 +6950,11 @@ function createEngineCore(config, hooks) {
     rebalancingIndexes,
     requireManager,
     onClose: hooks?.onIndexClose,
-    onOpen: hooks?.onIndexOpen
+    onOpen: (indexName) => {
+      heapPressureNotifier.check(indexName);
+      return hooks?.onIndexOpen?.(indexName);
+    },
+    onAccess: (indexName) => orchestrator.noteAccess(indexName)
   });
   const mutationCtx = {
     executor,
@@ -6396,11 +6967,13 @@ function createEngineCore(config, hooks) {
     requireIndex,
     requireManager,
     bufferIfRebalancing,
+    awaitRebalanceReplay: (indexName) => waqMap.get(indexName)?.whenReplayed() ?? Promise.resolve(),
     isRebalancing: (indexName) => rebalancingIndexes.has(indexName),
     pendingRebalanceWrites: (indexName) => waqMap.get(indexName)?.size ?? 0,
     rebalanceTargetPartitionCount: (indexName) => rebalanceTargets.get(indexName),
     bufferedDocState: (indexName, docId) => waqMap.get(indexName)?.bufferedDocState(docId),
-    checkWatermark: watermarkNotifier.check
+    checkWatermark: watermarkNotifier.check,
+    checkHeapPressure: heapPressureNotifier.check
   };
   const rebalanceCtx = {
     rebalancer,
@@ -6417,7 +6990,6 @@ function createEngineCore(config, hooks) {
   };
   return {
     executor,
-    promoter,
     pluginRegistry,
     durability,
     invalidation,
@@ -6437,6 +7009,7 @@ function createEngineCore(config, hooks) {
     requireManager,
     bufferIfRebalancing,
     watermarkNotifier,
+    heapPressureNotifier,
     analysisRebuild,
     indexState,
     mutationCtx,
@@ -6444,108 +7017,18 @@ function createEngineCore(config, hooks) {
   };
 }
 
-// src/engine/validation.ts
-var INDEX_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-var MAX_DOC_ID_LENGTH = 512;
-var BATCH_CHUNK_SIZE = 1e3;
-var DEFAULT_LIMIT = DEFAULT_PAGE_SIZE;
-var DEFAULT_OFFSET = 0;
-function now() {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return performance.now();
-  }
-  return Date.now();
-}
-function validateIndexName(name) {
-  if (!name || name.length === 0) {
-    throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, "Index name must not be empty", { indexName: name });
-  }
-  if (name.length > MAX_INDEX_NAME_LENGTH) {
-    throw new NarsilError(
-      ErrorCodes.INDEX_NOT_FOUND,
-      `Index name must not exceed ${MAX_INDEX_NAME_LENGTH} characters`,
-      {
-        indexName: name,
-        length: name.length
-      }
-    );
-  }
-  if (!INDEX_NAME_PATTERN.test(name)) {
-    throw new NarsilError(
-      ErrorCodes.INDEX_NOT_FOUND,
-      `Index name "${name}" contains invalid characters; use alphanumeric, dots, hyphens, and underscores only`,
-      { indexName: name }
-    );
-  }
-  if (name.includes("..")) {
-    throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Index name "${name}" must not contain ".."`, { indexName: name });
-  }
-}
-function validateDocId(docId) {
-  if (!docId || docId.length === 0) {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Document ID must not be empty", { docId });
-  }
-  if (docId.length > MAX_DOC_ID_LENGTH) {
-    throw new NarsilError(
-      ErrorCodes.DOC_VALIDATION_FAILED,
-      `Document ID must not exceed ${MAX_DOC_ID_LENGTH} characters`,
-      {
-        docId,
-        length: docId.length
-      }
-    );
-  }
-  if (docId.includes("\0")) {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Document ID must not contain null bytes", { docId });
+// src/engine/index-lifecycle.ts
+async function createEngineIndex(core, config, name, indexConfig, indexUuid) {
+  core.guardShutdown();
+  validateIndexName(name);
+  if (core.indexRegistry.has(name)) {
+    throw new NarsilError(ErrorCodes.INDEX_ALREADY_EXISTS, `Index "${name}" already exists`, { indexName: name });
   }
-}
-function validatePartitionConfig(partitions) {
-  const { maxDocsPerPartition, maxPartitions, watermark } = partitions;
-  if (maxDocsPerPartition !== void 0 && (!Number.isInteger(maxDocsPerPartition) || maxDocsPerPartition < 1)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "partitions.maxDocsPerPartition must be a positive integer", {
-      maxDocsPerPartition
-    });
-  }
-  if (maxPartitions !== void 0 && (!Number.isInteger(maxPartitions) || maxPartitions < 1)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "partitions.maxPartitions must be a positive integer", {
-      maxPartitions
-    });
-  }
-  if (watermark !== void 0 && (typeof watermark !== "number" || !(watermark > 0) || watermark > 1)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "partitions.watermark must be above 0 and at most 1", {
-      watermark
-    });
-  }
-}
-function validateBM25Params(bm25) {
-  if (bm25 === void 0) return;
-  const { k1, b } = bm25;
-  if (k1 !== void 0 && (!Number.isFinite(k1) || k1 < 0)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "bm25.k1 must be a finite number at or above 0", { k1 });
-  }
-  if (b !== void 0 && (!Number.isFinite(b) || b < 0 || b > 1)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "bm25.b must be between 0 and 1", { b });
-  }
-}
-function clampLimit(limit) {
-  return clampRowCount(limit, DEFAULT_LIMIT);
-}
-function clampOffset(offset) {
-  return clampRowCount(offset, DEFAULT_OFFSET);
-}
-
-// src/engine/index-lifecycle.ts
-async function createEngineIndex(core, config, name, indexConfig, indexUuid) {
-  core.guardShutdown();
-  validateIndexName(name);
-  if (core.indexRegistry.has(name)) {
-    throw new NarsilError(ErrorCodes.INDEX_ALREADY_EXISTS, `Index "${name}" already exists`, { indexName: name });
-  }
-  validateSchema(indexConfig.schema);
-  validateVectorPromotion(indexConfig.vectorPromotion);
-  validateBM25Params(indexConfig.bm25);
-  if (indexConfig.partitions) {
-    validatePartitionConfig(indexConfig.partitions);
+  validateSchema(indexConfig.schema);
+  validateVectorPromotion(indexConfig.vectorPromotion);
+  validateBM25Params(indexConfig.bm25);
+  if (indexConfig.partitions) {
+    validatePartitionConfig(indexConfig.partitions);
   }
   if (core.durability) {
     if (indexConfig.tokenizer !== void 0 && typeof indexConfig.tokenizer !== "string") {
@@ -7037,6 +7520,12 @@ async function embedChunkDocuments(entry, documents, chunkStart, chunkEnd, signa
   }
 }
 
+// src/engine/mutations/write-visibility.ts
+async function awaitWriteVisibility(ctx, indexName) {
+  await ctx.awaitRebalanceReplay(indexName);
+  await ctx.orchestrator.awaitWrites(indexName);
+}
+
 // src/engine/mutations/insert.ts
 async function insertDocument(ctx, indexName, document, docId, options) {
   ctx.guardShutdown();
@@ -7122,6 +7611,8 @@ async function insertDocument(ctx, indexName, document, docId, options) {
   }
   if (buffered) {
     ctx.checkWatermark(indexName);
+    ctx.checkHeapPressure(indexName);
+    if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
     return resolvedDocId;
   }
   try {
@@ -7144,7 +7635,9 @@ async function insertDocument(ctx, indexName, document, docId, options) {
     }
   }
   ctx.checkWatermark(indexName);
-  await ctx.orchestrator.checkPromotion();
+  ctx.checkHeapPressure(indexName);
+  await ctx.orchestrator.scaleOutReadyIndexes();
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
   return resolvedDocId;
 }
 
@@ -7298,7 +7791,6 @@ async function applyAdmittedDocuments(ctx, indexName, admitted, options, failed)
 }
 
 // src/engine/mutations/segment-replication.ts
-var MIN_DOCUMENTS_FOR_SEGMENTS = 64;
 function shardCount(documentCount, workers) {
   if (workers <= 1) return 1;
   return Math.max(1, Math.min(workers, Math.ceil(documentCount / MIN_DOCUMENTS_FOR_SEGMENTS)));
@@ -7558,7 +8050,9 @@ async function insertBatchViaSegments(ctx, indexName, documents, options) {
     vecIndexes.get(fieldPath)?.scheduleBuild();
   }
   ctx.checkWatermark(indexName);
-  await ctx.orchestrator.checkPromotion();
+  ctx.checkHeapPressure(indexName);
+  await ctx.orchestrator.scaleOutReadyIndexes();
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
   return { succeeded: outcome.succeeded, failed };
 }
 
@@ -7566,7 +8060,7 @@ async function insertBatchViaSegments(ctx, indexName, documents, options) {
 async function insertDocumentBatch(ctx, indexName, documents, options) {
   ctx.guardShutdown();
   const entry = ctx.requireIndex(indexName);
-  await ctx.orchestrator.promoteBeforeBatch(indexName, documents.length);
+  await ctx.orchestrator.scaleOutBeforeBatch(indexName, documents.length);
   if (documents.length >= MIN_DOCUMENTS_FOR_SEGMENTS && !ctx.isRebalancing(indexName) && ctx.orchestrator.segmentBuildConcurrency(indexName) > 0) {
     return insertBatchViaSegments(ctx, indexName, documents, options);
   }
@@ -7720,12 +8214,14 @@ async function insertDocumentBatch(ctx, indexName, documents, options) {
     }
   }
   ctx.checkWatermark(indexName);
-  await ctx.orchestrator.checkPromotion();
+  ctx.checkHeapPressure(indexName);
+  await ctx.orchestrator.scaleOutReadyIndexes();
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
   return { succeeded, failed };
 }
 
 // src/engine/mutations/remove.ts
-async function removeDocument(ctx, indexName, docId) {
+async function removeDocument(ctx, indexName, docId, options) {
   ctx.guardShutdown();
   ctx.requireIndex(indexName);
   validateDocId(docId);
@@ -7764,6 +8260,7 @@ async function removeDocument(ctx, indexName, docId) {
     await applyRemove();
   }
   if (buffered) {
+    if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
     return;
   }
   try {
@@ -7777,8 +8274,9 @@ async function removeDocument(ctx, indexName, docId) {
     docId,
     requestId: `replicate-remove-${docId}`
   });
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
 }
-async function removeDocumentBatch(ctx, indexName, docIds) {
+async function removeDocumentBatch(ctx, indexName, docIds, options) {
   ctx.guardShutdown();
   ctx.requireIndex(indexName);
   const succeeded = [];
@@ -7806,6 +8304,7 @@ async function removeDocumentBatch(ctx, indexName, docIds) {
   } finally {
     manager.endBatchRemove();
   }
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
   return { succeeded, failed };
 }
 
@@ -7823,7 +8322,7 @@ function prepareUpdatePartitionDoc(document, extractedVectors) {
   }
   return { partitionDoc };
 }
-async function updateDocument(ctx, indexName, docId, document) {
+async function updateDocument(ctx, indexName, docId, document, options) {
   ctx.guardShutdown();
   const entry = ctx.requireIndex(indexName);
   validateDocId(docId);
@@ -7925,6 +8424,8 @@ async function updateDocument(ctx, indexName, docId, document) {
     await applyUpdate();
   }
   if (buffered) {
+    ctx.checkHeapPressure(indexName);
+    if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
     return;
   }
   try {
@@ -7951,8 +8452,10 @@ async function updateDocument(ctx, indexName, docId, document) {
       vecIndex.scheduleBuild();
     }
   }
+  ctx.checkHeapPressure(indexName);
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
 }
-async function updateDocumentBatch(ctx, indexName, updates) {
+async function updateDocumentBatch(ctx, indexName, updates, options) {
   ctx.guardShutdown();
   const entry = ctx.requireIndex(indexName);
   const succeeded = [];
@@ -7991,14 +8494,19 @@ async function updateDocumentBatch(ctx, indexName, updates) {
       vecIndex.scheduleBuild();
     }
   }
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
   return { succeeded, failed };
 }
 
 // src/partitioning/write-ahead-queue.ts
-function createWriteAheadQueue(maxSize = 1e4) {
+function createWriteAheadQueue(maxSize = DEFAULT_WRITE_AHEAD_QUEUE_MAX_SIZE) {
   const entries = [];
   const docStates = /* @__PURE__ */ new Map();
   let nextSequence = 1;
+  let resolveReplayed = () => void 0;
+  const replayed = new Promise((resolve) => {
+    resolveReplayed = resolve;
+  });
   return {
     push(entry) {
       if (entries.length >= maxSize) {
@@ -8025,6 +8533,12 @@ function createWriteAheadQueue(maxSize = 1e4) {
     bufferedDocState(docId) {
       return docStates.get(docId);
     },
+    whenReplayed() {
+      return replayed;
+    },
+    markReplayed() {
+      resolveReplayed();
+    },
     get size() {
       return entries.length;
     },
@@ -8198,12 +8712,11 @@ async function executeRebalance(manager, indexName, targetPartitionCount, ctx) {
     const oldCount = manager.partitionCount;
     await ctx.rebalancer.rebalance(manager, targetPartitionCount, ctx.router, (progress) => {
       if (progress.phase === "complete") {
-        const handlers = ctx.eventHandlers.get("partitionRebalance");
-        if (handlers) {
-          for (const handler of handlers) {
-            handler({ indexName, oldCount, newCount: targetPartitionCount });
-          }
-        }
+        emitEngineEvent(ctx.eventHandlers, "partitionRebalance", {
+          indexName,
+          oldCount,
+          newCount: targetPartitionCount
+        });
       }
     });
     try {
@@ -8243,6 +8756,7 @@ async function executeRebalance(manager, indexName, targetPartitionCount, ctx) {
     ctx.rebalancingIndexes.delete(indexName);
     ctx.rebalanceTargets.delete(indexName);
     ctx.waqMap.delete(indexName);
+    waq.markReplayed();
   }
   ctx.checkWatermark(indexName);
 }
@@ -8670,6 +9184,7 @@ function readProcessMemory() {
     return {
       heapUsed: usage.heapUsed,
       heapTotal: usage.heapTotal,
+      heapLimit: readHeapStatistics()?.limitBytes ?? null,
       external: usage.external,
       rss: usage.rss
     };
@@ -8678,1209 +9193,6 @@ function readProcessMemory() {
   }
 }
 
-// src/search/cursor-binding.ts
-var ABSENT_TAG = 0;
-var NULL_TAG = 1;
-var FALSE_TAG = 2;
-var TRUE_TAG = 3;
-var NUMBER_TAG = 4;
-var STRING_TAG = 5;
-var LIST_TAG = 6;
-var MAP_TAG = 7;
-var encoder = new TextEncoder();
-function ensureCapacity(stream, extra) {
-  if (stream.length + extra <= stream.bytes.length) return;
-  const grown = new Uint8Array(Math.max(stream.bytes.length * 2, stream.length + extra));
-  grown.set(stream.bytes.subarray(0, stream.length));
-  stream.bytes = grown;
-}
-function writeByte(stream, value) {
-  ensureCapacity(stream, 1);
-  stream.bytes[stream.length] = value;
-  stream.length += 1;
-}
-function writeUint32(stream, value) {
-  ensureCapacity(stream, 4);
-  stream.bytes[stream.length] = value >>> 24 & 255;
-  stream.bytes[stream.length + 1] = value >>> 16 & 255;
-  stream.bytes[stream.length + 2] = value >>> 8 & 255;
-  stream.bytes[stream.length + 3] = value & 255;
-  stream.length += 4;
-}
-var numberBytes = new DataView(new ArrayBuffer(8));
-function writeNumber(stream, value) {
-  numberBytes.setFloat64(0, value, false);
-  ensureCapacity(stream, 8);
-  for (let i = 0; i < 8; i++) {
-    stream.bytes[stream.length + i] = numberBytes.getUint8(i);
-  }
-  stream.length += 8;
-}
-function writeString(stream, value) {
-  const encoded = encoder.encode(value);
-  writeUint32(stream, encoded.length);
-  ensureCapacity(stream, encoded.length);
-  stream.bytes.set(encoded, stream.length);
-  stream.length += encoded.length;
-}
-function writeValue(stream, value) {
-  if (value === void 0) {
-    writeByte(stream, ABSENT_TAG);
-    return;
-  }
-  if (value === null) {
-    writeByte(stream, NULL_TAG);
-    return;
-  }
-  if (typeof value === "boolean") {
-    writeByte(stream, value ? TRUE_TAG : FALSE_TAG);
-    return;
-  }
-  if (typeof value === "number") {
-    writeByte(stream, NUMBER_TAG);
-    writeNumber(stream, value);
-    return;
-  }
-  if (typeof value === "string") {
-    writeByte(stream, STRING_TAG);
-    writeString(stream, value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    writeByte(stream, LIST_TAG);
-    writeUint32(stream, value.length);
-    for (const member of value) {
-      writeValue(stream, member ?? null);
-    }
-    return;
-  }
-  const record = value;
-  const keys = Object.keys(record).sort(compareCodePoints);
-  writeByte(stream, MAP_TAG);
-  writeUint32(stream, keys.length);
-  for (const key of keys) {
-    writeByte(stream, STRING_TAG);
-    writeString(stream, key);
-    writeValue(stream, record[key] ?? null);
-  }
-}
-function boundVectorOf(vector) {
-  if (vector === void 0) return void 0;
-  const bound = { ...vector };
-  if (vector.value !== void 0) {
-    bound.value = Array.from(vector.value, Math.fround);
-  }
-  if (vector.text !== void 0) {
-    delete bound.value;
-  }
-  return bound;
-}
-var FILTERS_SLOT = 2;
-var BOUND_SLOT_COUNT = 15;
-function bindingOf(values) {
-  const stream = { bytes: new Uint8Array(256), length: 0 };
-  for (const value of values) {
-    writeValue(stream, value);
-  }
-  return fnv1aBytes(stream.bytes.subarray(0, stream.length)).toString(16).padStart(8, "0");
-}
-function queryBindingOf(params) {
-  return bindingOf([
-    params.term,
-    params.fields,
-    params.filters,
-    params.boost,
-    params.minScore,
-    params.termMatch,
-    params.tolerance,
-    params.prefixLength,
-    params.prefix,
-    params.exact,
-    params.pinned,
-    params.mode,
-    params.hybrid,
-    boundVectorOf(params.vector),
-    params.scoring ?? "local"
-  ]);
-}
-function listBindingOf(filters) {
-  const values = new Array(BOUND_SLOT_COUNT).fill(void 0);
-  values[FILTERS_SLOT] = filters;
-  return bindingOf(values);
-}
-
-// src/engine/list-documents/index.ts
-function clampListLimit(limit) {
-  const clamped = Math.max(1, clampLimit(limit));
-  requireWithinResultWindow(clamped, 0);
-  return clamped;
-}
-function firstIdAfter(sorted, anchor) {
-  let low = 0;
-  let high = sorted.length;
-  while (low < high) {
-    const mid = low + high >>> 1;
-    if (compareCodePoints(sorted[mid], anchor) <= 0) low = mid + 1;
-    else high = mid;
-  }
-  return low;
-}
-function collectFilterMatches(partitions, filters, schema) {
-  const perPartition = partitions.map((partition) => partition.filterMatches(filters, schema));
-  let total = 0;
-  for (const matches of perPartition) total += matches.count;
-  return { matchesFor: (partitionIndex) => perPartition[partitionIndex] ?? null, total };
-}
-function collectCandidates(partition, anchor, matches, wanted, out) {
-  const sorted = partition.sortedDocIds();
-  let index = anchor === null ? 0 : firstIdAfter(sorted, anchor);
-  let taken = 0;
-  while (index < sorted.length && taken < wanted) {
-    const docId = sorted[index];
-    index++;
-    if (matches !== null && !matches.hasExternal(docId)) continue;
-    out.push(docId);
-    taken++;
-  }
-}
-function pageInIdOrder(partitions, cursor, filtered, limit, binding) {
-  const anchor = cursor === null ? null : cursor.anchor;
-  const candidates = [];
-  for (let index = 0; index < partitions.length; index++) {
-    collectCandidates(
-      partitions[index],
-      anchor,
-      filtered === null ? null : filtered.matchesFor(index),
-      limit + 1,
-      candidates
-    );
-  }
-  candidates.sort(compareCodePoints);
-  const hasMore = candidates.length > limit;
-  const ids = hasMore ? candidates.slice(0, limit) : candidates;
-  const nextCursor = hasMore && ids.length > 0 ? { anchor: ids[ids.length - 1], score: null, sortKey: null, sortSignature: null, binding } : null;
-  return { ids, nextCursor };
-}
-function pageInSortOrder(partitions, cursor, filtered, limit, sort, signature, schema, binding) {
-  const normalized = normalizeSort(sort);
-  const fields = normalized.map((entry) => entry.field);
-  const directions = normalized.map((entry) => entry.direction);
-  const flatSchema = flattenSchema(schema);
-  const fieldTypes = fields.map((field) => flatSchema[field]);
-  const request = {
-    fields,
-    directions,
-    fieldTypes,
-    limit: limit + 1,
-    anchorKey: cursor === null ? null : cursor.sortKey,
-    anchorId: cursor === null ? null : cursor.anchor
-  };
-  const merged = [];
-  for (let index = 0; index < partitions.length; index++) {
-    const matches = filtered === null ? null : filtered.matchesFor(index);
-    for (const entry of partitions[index].sortedPage({ ...request, matches })) merged.push(entry);
-  }
-  merged.sort((a, b) => compareComparableKeys(a.key, b.key, directions) || compareCodePoints(a.id, b.id));
-  const hasMore = merged.length > limit;
-  const page = hasMore ? merged.slice(0, limit) : merged;
-  const last = page[page.length - 1];
-  const nextCursor = hasMore && last !== void 0 ? { anchor: last.id, score: null, sortKey: last.key, sortSignature: signature, binding } : null;
-  return { ids: page.map((entry) => entry.id), nextCursor };
-}
-function countAcrossPartitions(manager, partitionIds, partitions) {
-  if (partitionIds === void 0) {
-    return manager.countDocuments();
-  }
-  let total = 0;
-  for (const partition of partitions) {
-    total += partition.count();
-  }
-  return total;
-}
-function executeListDocuments(params, context) {
-  const { manager, schema } = context;
-  const startTime = now();
-  const limit = clampListLimit(params.limit);
-  const signature = sortSignatureOf(params.sort);
-  requireSortableFields(params.sort, schema);
-  const binding = listBindingOf(params.filters);
-  let cursor = null;
-  if (params.cursor !== void 0) {
-    cursor = decodePageCursor(params.cursor);
-    requireMatchingCursor(cursor, params.cursor, signature, false, binding);
-  }
-  const partitions = context.partitionIds === void 0 ? manager.getAllPartitions() : context.partitionIds.map((partitionId) => manager.partitionAt(partitionId)).filter((partition) => partition !== void 0);
-  const filtered = params.filters === void 0 ? null : collectFilterMatches(partitions, params.filters, schema);
-  const total = filtered === null ? countAcrossPartitions(manager, context.partitionIds, partitions) : filtered.total;
-  const page = params.sort === void 0 || signature === null ? pageInIdOrder(partitions, cursor, filtered, limit, binding) : pageInSortOrder(partitions, cursor, filtered, limit, params.sort, signature, schema, binding);
-  const projection = resolveProjection(params.document);
-  const documents = [];
-  for (const docId of page.ids) {
-    if (projection.kind === "none") {
-      documents.push({ id: docId, document: {} });
-      continue;
-    }
-    const stored = manager.get(docId, projection);
-    if (stored === void 0) continue;
-    documents.push({ id: docId, document: stored });
-  }
-  if (page.nextCursor === null) {
-    for (const partition of partitions) partition.releaseSortedDocIds();
-  }
-  return {
-    documents,
-    cursor: page.nextCursor === null ? null : encodePageCursor(page.nextCursor),
-    total,
-    elapsed: now() - startTime
-  };
-}
-
-// src/search/grouping.ts
-function getNestedValue2(obj, path) {
-  const segments = path.split(".");
-  let current = obj;
-  for (const segment of segments) {
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return void 0;
-    }
-    if (!Object.hasOwn(current, segment)) {
-      return void 0;
-    }
-    current = current[segment];
-  }
-  return current;
-}
-function applyGrouping(hits, group, getDocument) {
-  if (!group.fields || group.fields.length === 0) {
-    return [{ values: {}, hits }];
-  }
-  const groupMap = /* @__PURE__ */ new Map();
-  for (const hit of hits) {
-    const doc = getDocument(hit.id);
-    const fieldValues = [];
-    const valuesRecord = {};
-    for (const field of group.fields) {
-      const value = doc ? getNestedValue2(doc, field) : void 0;
-      fieldValues.push(value);
-      valuesRecord[field] = value;
-    }
-    const compositeKey = JSON.stringify(fieldValues);
-    const existing = groupMap.get(compositeKey);
-    if (existing) {
-      existing.hits.push(hit);
-    } else {
-      groupMap.set(compositeKey, { values: valuesRecord, hits: [hit] });
-    }
-  }
-  const groups = [];
-  for (const entry of groupMap.values()) {
-    let groupHits = entry.hits;
-    if (group.maxPerGroup !== void 0 && group.maxPerGroup > 0) {
-      groupHits = groupHits.slice(0, group.maxPerGroup);
-    }
-    const result = { values: entry.values, hits: groupHits };
-    if (group.reduce) {
-      const folded = foldGroupReducer(
-        group.reduce,
-        groupHits.map((hit) => ({ document: getDocument(hit.id), score: hit.score ?? 0 }))
-      );
-      if (folded.reducerError !== void 0) {
-        result.reducerError = folded.reducerError;
-      } else {
-        result.reduced = folded.reduced;
-      }
-    }
-    groups.push(result);
-  }
-  groups.sort((a, b) => {
-    const aScore = a.hits.length > 0 ? a.hits[0].score ?? 0 : 0;
-    const bScore = b.hits.length > 0 ? b.hits[0].score ?? 0 : 0;
-    if (aScore !== bScore) return bScore - aScore;
-    const aId = a.hits.length > 0 ? a.hits[0].id : "";
-    const bId = b.hits.length > 0 ? b.hits[0].id : "";
-    return compareCodePoints(aId, bId);
-  });
-  if (group.limit !== void 0 && Number.isFinite(group.limit) && group.limit >= 0) {
-    const cap = Math.floor(group.limit);
-    if (groups.length > cap) {
-      groups.length = cap;
-    }
-  }
-  return groups;
-}
-function foldGroupReducer(reduce, rows) {
-  try {
-    let accumulator = reduce.initialValue();
-    for (const row of rows) {
-      if (row.document !== void 0) {
-        accumulator = reduce.reducer(accumulator, row.document, row.score);
-      }
-    }
-    return { reduced: accumulator };
-  } catch (err) {
-    return { reducerError: err instanceof Error ? err.message : String(err) };
-  }
-}
-
-// src/search/pinning.ts
-function dedupePinnedEntries(pinned) {
-  const deduped = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of pinned) {
-    if (seen.has(entry.docId)) continue;
-    seen.add(entry.docId);
-    deduped.push(entry);
-  }
-  return deduped;
-}
-function applyPinning(hits, pinned, resolveDoc) {
-  const result = hits.slice();
-  const deduped = dedupePinnedEntries(pinned);
-  const pinnedDocIds = new Set(deduped.map((entry) => entry.docId));
-  for (let i = result.length - 1; i >= 0; i--) {
-    if (pinnedDocIds.has(result[i].id)) {
-      result.splice(i, 1);
-    }
-  }
-  const sorted = deduped.sort((a, b) => a.position - b.position);
-  for (const entry of sorted) {
-    const doc = resolveDoc(entry.docId);
-    if (!doc) continue;
-    const pos = Math.max(0, Math.min(entry.position, result.length));
-    result.splice(pos, 0, doc);
-  }
-  return result;
-}
-
-// src/highlighting/highlighter.ts
-function buildTokenCharOffsets(text, originalTokens) {
-  const offsets = [];
-  let searchFrom = 0;
-  for (const token of originalTokens) {
-    const idx = text.indexOf(token, searchFrom);
-    if (idx === -1) continue;
-    offsets.push({ start: idx, end: idx + token.length });
-    searchFrom = idx + token.length;
-  }
-  return offsets;
-}
-function mergeOverlapping(ranges) {
-  if (ranges.length === 0) return [];
-  const sorted = [...ranges].sort((a, b) => a.start - b.start);
-  const merged = [sorted[0]];
-  for (let i = 1; i < sorted.length; i++) {
-    const prev = merged[merged.length - 1];
-    const curr = sorted[i];
-    if (curr.start <= prev.end) {
-      prev.end = Math.max(prev.end, curr.end);
-    } else {
-      merged.push(curr);
-    }
-  }
-  return merged;
-}
-function findDensestWindow(positions, text, windowSize) {
-  if (positions.length === 0) {
-    return { start: 0, end: Math.min(windowSize, text.length) };
-  }
-  let bestStart = 0;
-  let bestCount = 0;
-  for (const pos of positions) {
-    const windowStart = Math.max(0, pos.start - Math.floor(windowSize / 2));
-    const windowEnd = Math.min(text.length, windowStart + windowSize);
-    const adjustedStart = Math.max(0, windowEnd - windowSize);
-    let count = 0;
-    for (const p of positions) {
-      if (p.start >= adjustedStart && p.end <= windowEnd) {
-        count++;
-      }
-    }
-    if (count > bestCount) {
-      bestCount = count;
-      bestStart = adjustedStart;
-    }
-  }
-  return { start: bestStart, end: Math.min(text.length, bestStart + windowSize) };
-}
-function applySnippetTruncation(taggedText, originalText, positions, maxLen, preTag, postTag) {
-  if (maxLen <= 0 || originalText.length <= maxLen) {
-    return { snippet: taggedText, adjustedPositions: positions };
-  }
-  const window = findDensestWindow(positions, originalText, maxLen);
-  const snippetRaw = originalText.substring(window.start, window.end);
-  const adjustedPositions = [];
-  for (const pos of positions) {
-    if (pos.start >= window.start && pos.end <= window.end) {
-      adjustedPositions.push({
-        start: pos.start - window.start,
-        end: pos.end - window.start
-      });
-    }
-  }
-  let snippet = snippetRaw;
-  const sortedDesc = [...adjustedPositions].sort((a, b) => b.start - a.start);
-  for (const pos of sortedDesc) {
-    snippet = snippet.substring(0, pos.start) + preTag + snippet.substring(pos.start, pos.end) + postTag + snippet.substring(pos.end);
-  }
-  const needsLeadingEllipsis = window.start > 0;
-  const needsTrailingEllipsis = window.end < originalText.length;
-  if (needsLeadingEllipsis) snippet = `...${snippet}`;
-  if (needsTrailingEllipsis) snippet = `${snippet}...`;
-  return { snippet, adjustedPositions };
-}
-function highlightField(text, queryTokens, language, options) {
-  const preTag = options?.preTag ?? "<mark>";
-  const postTag = options?.postTag ?? "</mark>";
-  const maxSnippetLength = options?.maxSnippetLength ?? 200;
-  if (text.length === 0) {
-    return { snippet: text, positions: [] };
-  }
-  const fieldResult = tokenize(text, language, { stem: false, removeStopWords: false });
-  if (fieldResult.tokens.length === 0) {
-    return { snippet: text, positions: [] };
-  }
-  const lowercaseText = text.normalize("NFC").toLowerCase();
-  const charOffsets = buildTokenCharOffsets(lowercaseText, fieldResult.originalTokens);
-  const stemmedQueryTokens = queryTokens.map((qt) => {
-    if (language.stemmer) {
-      return language.stemmer(qt.token.toLowerCase());
-    }
-    return qt.token.toLowerCase();
-  });
-  const matchedRanges = [];
-  const prefixToken = options?.prefixToken;
-  for (let i = 0; i < fieldResult.tokens.length; i++) {
-    if (i >= charOffsets.length) break;
-    const fieldToken = fieldResult.tokens[i].token;
-    const stemmedField = language.stemmer ? language.stemmer(fieldToken) : fieldToken;
-    if (prefixToken !== void 0 && fieldToken.startsWith(prefixToken)) {
-      matchedRanges.push({ start: charOffsets[i].start, end: charOffsets[i].end });
-      continue;
-    }
-    for (const stemmedQuery of stemmedQueryTokens) {
-      if (stemmedField === stemmedQuery) {
-        matchedRanges.push({ start: charOffsets[i].start, end: charOffsets[i].end });
-        break;
-      }
-    }
-  }
-  const mergedPositions = mergeOverlapping(matchedRanges);
-  if (mergedPositions.length === 0) {
-    if (maxSnippetLength > 0 && text.length > maxSnippetLength) {
-      const truncated = text.substring(0, maxSnippetLength);
-      return { snippet: `${truncated}...`, positions: [] };
-    }
-    return { snippet: text, positions: [] };
-  }
-  if (maxSnippetLength > 0 && text.length > maxSnippetLength) {
-    const { snippet, adjustedPositions } = applySnippetTruncation(
-      text,
-      text,
-      mergedPositions,
-      maxSnippetLength,
-      preTag,
-      postTag
-    );
-    return { snippet, positions: adjustedPositions };
-  }
-  let result = text;
-  const sortedDesc = [...mergedPositions].sort((a, b) => b.start - a.start);
-  for (const pos of sortedDesc) {
-    result = result.substring(0, pos.start) + preTag + result.substring(pos.start, pos.end) + postTag + result.substring(pos.end);
-  }
-  return { snippet: result, positions: mergedPositions };
-}
-
-// src/engine/query/highlight.ts
-function applyHighlights(hits, params, language, analysis) {
-  if (!params.highlight) return;
-  const queryTokenResult = tokenize(params.term ?? "", language, {
-    stem: true,
-    removeStopWords: true,
-    customTokenizer: analysis.customTokenizer,
-    stopWordOverride: analysis.stopWords
-  });
-  let prefixToken;
-  if (params.prefix === true && params.exact !== true && queryTokenResult.tokens.length > 0) {
-    const lastPosition = queryTokenResult.tokens[queryTokenResult.tokens.length - 1].position;
-    const unstemmed = tokenize(params.term ?? "", language, {
-      stem: false,
-      removeStopWords: true,
-      customTokenizer: analysis.customTokenizer,
-      stopWordOverride: analysis.stopWords
-    });
-    for (const t of unstemmed.tokens) {
-      if (t.position === lastPosition) {
-        prefixToken = t.token;
-        break;
-      }
-    }
-  }
-  for (const hit of hits) {
-    const highlights = {};
-    for (const field of params.highlight.fields) {
-      const doc = hit.document;
-      const fieldValue = doc[field];
-      if (typeof fieldValue === "string") {
-        highlights[field] = highlightField(fieldValue, queryTokenResult.tokens, language, {
-          preTag: params.highlight.preTag,
-          postTag: params.highlight.postTag,
-          maxSnippetLength: params.highlight.maxSnippetLength,
-          prefixToken
-        });
-      }
-    }
-    hit.highlights = highlights;
-  }
-}
-
-// src/engine/query/shared.ts
-function partitionsFor(manager, partitionIds) {
-  return partitionsIn(manager, partitionIds);
-}
-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;
-  }
-  if (!vecIndex.partitionsKnown()) {
-    vecIndex.assignPartitions((docId) => manager.partitionIdOf(docId));
-  }
-  return new Set(partitionIds);
-}
-function scoringConfigFor(params, context) {
-  const scoringMode = params.scoring ?? context.config.defaultScoring ?? "local";
-  if (scoringMode !== "broadcast") {
-    return { scoringMode, partitionIds: context.partitionIds };
-  }
-  return { scoringMode, globalStats: context.broadcastStats?.(context.indexName), partitionIds: context.partitionIds };
-}
-function broadcastStatsForWorker(params, context, scoring) {
-  if (scoring.scoringMode !== "broadcast" || scoring.globalStats === void 0) {
-    return void 0;
-  }
-  const term = params.term;
-  if (term === void 0 || term.trim().length === 0) {
-    return void 0;
-  }
-  return pruneStatsToQueryTerms(scoring.globalStats, term, context.language, context.manager.analysis);
-}
-function searchOptionsFor(manager) {
-  return {
-    bm25Params: manager.config.bm25,
-    stopWords: manager.analysis.stopWords,
-    customTokenizer: manager.analysis.customTokenizer
-  };
-}
-function collectFilterDocIds(manager, params, schema, partitionIds) {
-  const filterDocIds = /* @__PURE__ */ new Set();
-  if (!params.filters) return filterDocIds;
-  for (const partition of partitionsFor(manager, partitionIds)) {
-    const partitionFiltered = partition.applyFilters(params.filters, schema);
-    for (const docId of partitionFiltered) {
-      filterDocIds.add(docId);
-    }
-  }
-  return filterDocIds;
-}
-function vectorResultsToScored(results) {
-  return results.map((r) => ({
-    docId: r.docId,
-    score: r.score,
-    termFrequencies: {},
-    fieldLengths: {},
-    idf: {}
-  }));
-}
-function resolveVectorIndex(manager, fieldName) {
-  return manager.getVectorIndexes().get(fieldName);
-}
-function clampAlpha(alpha) {
-  if (alpha === void 0) return 0.5;
-  if (!Number.isFinite(alpha)) return 0.5;
-  if (alpha < 0) return 0;
-  if (alpha > 1) return 1;
-  return alpha;
-}
-
-// src/engine/query/sorted.ts
-function sortsWithoutScores(params) {
-  return params.includeScores !== true && params.includeScoreComponents !== true && params.minScore === void 0 && params.group === void 0 && params.pinned === void 0 && (params.termMatch === void 0 || params.termMatch === "any");
-}
-function executeSortedQueryPage(params, context, limit, offset, sortSignature) {
-  const { manager, language, config } = context;
-  const schema = config.schema;
-  let anchorKey = null;
-  let anchorId = null;
-  if (params.searchAfter !== void 0) {
-    const decoded = decodePageCursor(params.searchAfter);
-    requireMatchingCursor(decoded, params.searchAfter, sortSignature, true, context.cursorBinding);
-    anchorKey = decoded.sortKey;
-    anchorId = decoded.anchor;
-  }
-  const normalized = normalizeSort(params.sort);
-  const fields = normalized.map((entry) => entry.field);
-  const directions = normalized.map((entry) => entry.direction);
-  const flatSchema = flattenSchema(schema);
-  const fieldTypes = fields.map((field) => flatSchema[field]);
-  const options = searchOptionsFor(manager);
-  const partitions = partitionsFor(manager, context.partitionIds);
-  const partitionLimit = offset + limit + 1;
-  const merged = [];
-  const partitionFacets = [];
-  let count = 0;
-  for (const partition of partitions) {
-    const matches = fulltextMatches(partition, params, language, schema, options);
-    if (params.facets !== void 0) {
-      partitionFacets.push(
-        partition.computeFacets(
-          matches === null ? /* @__PURE__ */ new Set() : { ordinalBitset: matches.ordinalBitset() },
-          params.facets,
-          schema
-        )
-      );
-    }
-    if (matches === null || matches.count === 0) continue;
-    count += matches.count;
-    const page2 = partition.sortedPage({
-      fields,
-      directions,
-      fieldTypes,
-      limit: partitionLimit,
-      anchorKey,
-      anchorId,
-      matches
-    });
-    for (const entry of page2) merged.push(entry);
-  }
-  merged.sort((a, b) => compareComparableKeys(a.key, b.key, directions) || compareCodePoints(a.id, b.id));
-  const hasMore = merged.length > offset + limit;
-  const page = merged.slice(offset, offset + limit);
-  const last = page[page.length - 1];
-  let cursor;
-  if (hasMore && last !== void 0) {
-    cursor = encodePageCursor({
-      anchor: last.id,
-      score: null,
-      sortKey: last.key,
-      sortSignature,
-      binding: context.cursorBinding
-    });
-  }
-  return {
-    hits: page.map((entry) => ({ id: entry.id, document: void 0 })),
-    count,
-    cursor,
-    facets: partitionFacets.length > 0 ? mergeFacets(partitionFacets) : void 0
-  };
-}
-
-// src/search/fusion.ts
-function reciprocalRankFusion(lists, options) {
-  const k = options.k > 0 ? options.k : 60;
-  const scores = /* @__PURE__ */ new Map();
-  const docData = /* @__PURE__ */ new Map();
-  for (const list of lists) {
-    for (let rank = 0; rank < list.length; rank++) {
-      const doc = list[rank];
-      const rrfContribution = 1 / (k + rank + 1);
-      scores.set(doc.docId, (scores.get(doc.docId) ?? 0) + rrfContribution);
-      if (!docData.has(doc.docId)) {
-        docData.set(doc.docId, doc);
-      }
-    }
-  }
-  const result = [];
-  for (const [docId, score] of scores) {
-    const original = docData.get(docId);
-    if (!original) continue;
-    result.push({
-      docId,
-      score,
-      termFrequencies: original.termFrequencies,
-      fieldLengths: original.fieldLengths,
-      idf: original.idf
-    });
-  }
-  result.sort((a, b) => b.score - a.score || compareCodePoints(a.docId, b.docId));
-  return result;
-}
-function linearCombination(textResults, vectorResults, options) {
-  const { alpha } = options;
-  const normalizedText = minMaxNormalize(textResults);
-  const normalizedVector = minMaxNormalize(vectorResults);
-  const textScoreMap = /* @__PURE__ */ new Map();
-  for (const doc of normalizedText) {
-    textScoreMap.set(doc.docId, doc.score);
-  }
-  const textDocMap = /* @__PURE__ */ new Map();
-  for (const doc of textResults) {
-    textDocMap.set(doc.docId, doc);
-  }
-  const vectorScoreMap = /* @__PURE__ */ new Map();
-  for (const doc of normalizedVector) {
-    vectorScoreMap.set(doc.docId, doc.score);
-  }
-  const allDocIds = /* @__PURE__ */ new Set();
-  for (const doc of textResults) allDocIds.add(doc.docId);
-  for (const doc of vectorResults) allDocIds.add(doc.docId);
-  const result = [];
-  for (const docId of allDocIds) {
-    const tScore = textScoreMap.get(docId) ?? 0;
-    const vScore = vectorScoreMap.get(docId) ?? 0;
-    const combined = alpha * vScore + (1 - alpha) * tScore;
-    const original = textDocMap.get(docId);
-    result.push({
-      docId,
-      score: combined,
-      termFrequencies: original?.termFrequencies ?? {},
-      fieldLengths: original?.fieldLengths ?? {},
-      idf: original?.idf ?? {}
-    });
-  }
-  result.sort((a, b) => b.score - a.score || compareCodePoints(a.docId, b.docId));
-  return result;
-}
-function minMaxNormalize(docs) {
-  if (docs.length === 0) return [];
-  let min = docs[0].score;
-  let max = docs[0].score;
-  for (let i = 1; i < docs.length; i++) {
-    if (docs[i].score < min) min = docs[i].score;
-    if (docs[i].score > max) max = docs[i].score;
-  }
-  const range = max - min;
-  if (range === 0) {
-    return docs.map((d) => ({ docId: d.docId, score: 1 }));
-  }
-  return docs.map((d) => ({ docId: d.docId, score: (d.score - min) / range }));
-}
-
-// src/engine/query/vector.ts
-async function executeVectorSearch(params, manager, config, limit, offset, partitionIds) {
-  const vectorConfig = params.vector;
-  if (!vectorConfig || !vectorConfig.value) {
-    return { scored: [], totalMatched: 0 };
-  }
-  const vecIndex = resolveVectorIndex(manager, vectorConfig.field);
-  if (!vecIndex) {
-    return { scored: [], totalMatched: 0 };
-  }
-  let filterDocIds;
-  let filterPartitions;
-  if (params.filters) {
-    filterDocIds = collectFilterDocIds(manager, params, config.schema, partitionIds);
-    if (filterDocIds.size === 0) {
-      return { scored: [], totalMatched: 0 };
-    }
-  } else {
-    filterPartitions = partitionsForVectorSearch(manager, vecIndex, partitionIds);
-  }
-  const queryVec = new Float32Array(vectorConfig.value);
-  const k = limit + offset + 1;
-  const results = await vecIndex.searchParallel(queryVec, k, {
-    metric: vectorConfig.metric ?? "cosine",
-    minSimilarity: vectorConfig.similarity ?? -Infinity,
-    ...filterDocIds !== void 0 ? { filterDocIds } : {},
-    ...filterPartitions !== void 0 ? { filterPartitions } : {},
-    efSearch: vectorConfig.efSearch
-  });
-  const scored = vectorResultsToScored(results);
-  return { scored, totalMatched: scored.length };
-}
-async function executeHybridSearch(params, context, limit, offset) {
-  const { manager, language, config, workerSearch, indexName } = context;
-  const { vector: _vector, mode: _mode, hybrid: _hybrid, ...textOnlyParams } = params;
-  let filterDocIds;
-  if (params.filters) {
-    filterDocIds = collectFilterDocIds(manager, params, config.schema, context.partitionIds);
-    if (filterDocIds.size === 0) {
-      return { scored: [], totalMatched: 0 };
-    }
-  }
-  let textFanOutResult;
-  const scoring = scoringConfigFor(params, context);
-  const textWorkerResult = workerSearch ? await workerSearch(
-    indexName,
-    textOnlyParams,
-    broadcastStatsForWorker(textOnlyParams, context, scoring),
-    context.partitionIds
-  ) : null;
-  if (textWorkerResult) {
-    textFanOutResult = textWorkerResult;
-  } else {
-    textFanOutResult = await fanOutQuery(
-      manager,
-      textOnlyParams,
-      language,
-      config.schema,
-      scoring,
-      searchOptionsFor(manager)
-    );
-  }
-  const vectorConfig = params.vector;
-  if (!vectorConfig || !vectorConfig.value) {
-    return {
-      scored: textFanOutResult.scored,
-      totalMatched: textFanOutResult.totalMatched,
-      facets: textFanOutResult.facets
-    };
-  }
-  let vectorScored = [];
-  const vecIndex = resolveVectorIndex(manager, vectorConfig.field);
-  if (vecIndex) {
-    const queryVec = new Float32Array(vectorConfig.value);
-    const vectorK = limit + offset + 1;
-    const filterPartitions = filterDocIds === void 0 ? partitionsForVectorSearch(manager, vecIndex, context.partitionIds) : void 0;
-    const vectorResults = await vecIndex.searchParallel(queryVec, vectorK, {
-      metric: vectorConfig.metric ?? "cosine",
-      minSimilarity: vectorConfig.similarity ?? -Infinity,
-      ...filterDocIds !== void 0 ? { filterDocIds } : {},
-      ...filterPartitions !== void 0 ? { filterPartitions } : {},
-      efSearch: vectorConfig.efSearch
-    });
-    vectorScored = vectorResultsToScored(vectorResults);
-  }
-  const hybridConfig = params.hybrid ?? {};
-  const strategy = hybridConfig.strategy ?? "rrf";
-  let fusedScored;
-  if (strategy === "rrf") {
-    const rrfK = hybridConfig.k !== void 0 && hybridConfig.k > 0 ? hybridConfig.k : 60;
-    fusedScored = reciprocalRankFusion([textFanOutResult.scored, vectorScored], { k: rrfK });
-  } else {
-    const alpha = clampAlpha(hybridConfig.alpha);
-    fusedScored = linearCombination(textFanOutResult.scored, vectorScored, { alpha });
-  }
-  if (params.minScore !== void 0 && params.minScore > 0) {
-    const threshold = params.minScore;
-    fusedScored = fusedScored.filter((doc) => doc.score >= threshold);
-  }
-  return {
-    scored: fusedScored,
-    totalMatched: fusedScored.length,
-    facets: textFanOutResult.facets
-  };
-}
-
-// src/engine/query/index.ts
-async function executeQuery(params, context) {
-  const { manager, language, config, workerSearch, indexName } = context;
-  const startTime = now();
-  const limit = clampLimit(params.limit);
-  const offset = clampOffset(params.offset);
-  requireWithinResultWindow(limit, offset);
-  const sortFields = normalizeSort(params.sort);
-  const sortSignature = sortSignatureOf(params.sort);
-  const hasTerm = params.term !== void 0 && params.term.trim().length > 0;
-  const hasVector = params.vector !== void 0 && params.vector.value !== void 0;
-  const isHybridMode = params.mode === "hybrid" || hasTerm && hasVector;
-  const isVectorOnly = (params.mode === "vector" || hasVector && !hasTerm) && !isHybridMode;
-  if (sortSignature !== null && (isHybridMode || params.hybrid !== void 0)) {
-    throw new NarsilError(
-      ErrorCodes.SEARCH_INVALID_MODE,
-      "A hybrid query cannot carry a sort, because fusion defines the order of hybrid results",
-      { sort: sortFields.map((entry) => entry.field) }
-    );
-  }
-  requireSortableFields(params.sort, config.schema);
-  let paginated;
-  let nextCursor;
-  let count;
-  let facets;
-  let groups;
-  if (sortSignature !== null && hasTerm && !isVectorOnly && !isHybridMode && sortsWithoutScores(params)) {
-    const page = executeSortedQueryPage(params, context, limit, offset, sortSignature);
-    paginated = page.hits;
-    nextCursor = page.cursor;
-    count = page.count;
-    facets = page.facets;
-  } else {
-    const requestedVectorField = params.vector?.field;
-    const hasGlobalVectorIndex = requestedVectorField !== void 0 && manager.getVectorIndexes().has(requestedVectorField);
-    let fanOutResult;
-    if (isVectorOnly && hasGlobalVectorIndex) {
-      fanOutResult = await executeVectorSearch(params, manager, config, limit, offset, context.partitionIds);
-    } else if (isHybridMode && hasGlobalVectorIndex) {
-      fanOutResult = await executeHybridSearch(params, context, limit, offset);
-    } else {
-      const scoring = scoringConfigFor(params, context);
-      const workerResult = workerSearch ? await workerSearch(indexName, params, broadcastStatsForWorker(params, context, scoring), context.partitionIds) : null;
-      if (workerResult) {
-        fanOutResult = workerResult;
-      } else {
-        fanOutResult = await fanOutQuery(manager, params, language, config.schema, scoring, searchOptionsFor(manager));
-      }
-    }
-    const needsFullHits = params.sort !== void 0 || params.group !== void 0 || params.pinned !== void 0 || params.searchAfter !== void 0;
-    let hits;
-    if (needsFullHits) {
-      hits = fanOutResult.scored.map((scored) => ({
-        id: scored.docId,
-        score: scored.score,
-        document: void 0,
-        scoreComponents: params.includeScoreComponents ? { termFrequencies: scored.termFrequencies, fieldLengths: scored.fieldLengths, idf: scored.idf } : void 0
-      }));
-    } else {
-      const end = Math.min(offset + limit + 1, fanOutResult.scored.length);
-      hits = new Array(end);
-      for (let i = 0; i < end; i++) {
-        const scored = fanOutResult.scored[i];
-        hits[i] = {
-          id: scored.docId,
-          score: scored.score,
-          document: void 0,
-          scoreComponents: params.includeScoreComponents ? { termFrequencies: scored.termFrequencies, fieldLengths: scored.fieldLengths, idf: scored.idf } : void 0
-        };
-      }
-    }
-    const sortFieldNames = sortFields.map((entry) => entry.field);
-    const sortFlatSchema = sortFieldNames.length === 0 ? {} : flattenSchema(config.schema);
-    const sortFieldTypes = sortFieldNames.map((field) => sortFlatSchema[field]);
-    const sortKeyCache = /* @__PURE__ */ new Map();
-    const sortKeyOf = (docId) => {
-      let key = sortKeyCache.get(docId);
-      if (key === void 0) {
-        key = manager.sortValues(docId, sortFieldNames, sortFieldTypes);
-        sortKeyCache.set(docId, key);
-      }
-      return key;
-    };
-    if (params.sort) {
-      hits = applySorting(hits, params.sort, sortKeyOf);
-    }
-    if (params.group) {
-      groups = applyGrouping(hits, params.group, (docId) => manager.getRef(docId));
-    }
-    if (params.pinned && params.searchAfter === void 0 && context.partitionIds === void 0) {
-      hits = applyPinning(hits, params.pinned, (docId) => {
-        const doc = manager.getRef(docId);
-        if (!doc) return void 0;
-        return { id: docId, score: 0, document: doc };
-      });
-    }
-    let sortContext;
-    if (sortSignature !== null) {
-      sortContext = {
-        signature: sortSignature,
-        directions: sortFields.map((entry) => entry.direction),
-        sortKeyOf
-      };
-    }
-    const pinnedIds = params.pinned !== void 0 && params.searchAfter === void 0 ? new Set(params.pinned.map((entry) => entry.docId)) : void 0;
-    const paged = applyPagination(
-      hits,
-      limit,
-      offset,
-      context.cursorBinding,
-      params.searchAfter,
-      sortContext,
-      pinnedIds
-    );
-    paginated = paged.paginated;
-    nextCursor = paged.nextCursor;
-    count = fanOutResult.totalMatched;
-    facets = fanOutResult.facets;
-    if (sortSignature !== null && params.includeScores !== true) {
-      for (const hit of hits) hit.score = void 0;
-    }
-  }
-  const projection = resolveProjection(params.document);
-  if (projection.kind === "none") {
-    for (const hit of paginated) {
-      hit.document = {};
-    }
-  } else {
-    for (const hit of paginated) {
-      hit.document = manager.get(hit.id, projection) ?? {};
-    }
-  }
-  if (groups) {
-    for (const group of groups) {
-      for (const hit of group.hits) {
-        if (projection.kind === "none") {
-          hit.document = {};
-          continue;
-        }
-        hit.document = manager.get(hit.id, projection) ?? {};
-      }
-    }
-  }
-  if (params.highlight) {
-    applyHighlights(paginated, params, language, manager.analysis);
-  }
-  const elapsed = now() - startTime;
-  return {
-    hits: paginated,
-    count,
-    elapsed,
-    cursor: nextCursor,
-    facets,
-    groups,
-    coverage: coverageFor(manager, context.partitionIds)
-  };
-}
-async function executePreflight(params, context) {
-  const { manager, language, config, workerSearch, indexName } = context;
-  const startTime = now();
-  const hasTerm = params.term !== void 0 && params.term.trim().length > 0;
-  const hasVector = params.vector !== void 0 && params.vector.value !== void 0;
-  const isHybridMode = params.mode === "hybrid" || hasTerm && hasVector;
-  const isVectorOnly = (params.mode === "vector" || hasVector && !hasTerm) && !isHybridMode;
-  const requestedVectorField = params.vector?.field;
-  const hasGlobalVectorIndex = requestedVectorField !== void 0 && manager.getVectorIndexes().has(requestedVectorField);
-  let totalMatched;
-  const preflightLimit = 1e3;
-  const preflightOffset = 0;
-  if (isVectorOnly && hasGlobalVectorIndex) {
-    const result = await executeVectorSearch(
-      params,
-      manager,
-      config,
-      preflightLimit,
-      preflightOffset,
-      context.partitionIds
-    );
-    totalMatched = result.totalMatched;
-  } else if (isHybridMode && hasGlobalVectorIndex) {
-    const result = await executeHybridSearch(params, context, preflightLimit, preflightOffset);
-    totalMatched = result.totalMatched;
-  } else if (countsWithoutScores(params)) {
-    totalMatched = fanOutMatchCount(manager, params, language, config.schema, {
-      searchOptions: searchOptionsFor(manager),
-      partitionIds: context.partitionIds
-    });
-  } else {
-    const scoring = scoringConfigFor(params, context);
-    const workerResult = workerSearch ? await workerSearch(indexName, params, broadcastStatsForWorker(params, context, scoring), context.partitionIds) : null;
-    if (workerResult) {
-      totalMatched = workerResult.totalMatched;
-    } else {
-      const fanOutResult = await fanOutQuery(
-        manager,
-        params,
-        language,
-        config.schema,
-        scoring,
-        searchOptionsFor(manager)
-      );
-      totalMatched = fanOutResult.totalMatched;
-    }
-  }
-  const elapsed = now() - startTime;
-  return { count: totalMatched, elapsed };
-}
-
-// src/engine/resolve-vector-text.ts
-async function resolveVectorText(params, embeddingAdapter, signal, embeddingAdapterName) {
-  if (!params.vector) return params;
-  if (params.vector.text === void 0 && params.vector.value === void 0) return params;
-  if (params.vector.value !== void 0 && params.vector.text === void 0) return params;
-  if (params.vector.text !== void 0 && params.vector.value !== void 0) {
-    throw new NarsilError(ErrorCodes.EMBEDDING_CONFIG_INVALID, "Vector query cannot have both 'text' and 'value'");
-  }
-  if (!embeddingAdapter) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_CONFIG_INVALID,
-      embeddingAdapterName ? `Vector query with 'text' needs embedding adapter "${embeddingAdapterName}", which is not registered on this engine. Register it with registerEmbeddingAdapter or supply a raw vector.` : "Vector query with 'text' requires an embedding adapter on the index or instance",
-      embeddingAdapterName ? { adapter: embeddingAdapterName } : void 0
-    );
-  }
-  if (typeof params.vector.text !== "string") {
-    throw new NarsilError(
-      ErrorCodes.DOC_VALIDATION_FAILED,
-      `Vector query 'text' must be a string, got ${typeof params.vector.text}`
-    );
-  }
-  if (params.vector.text.length === 0) {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Vector query 'text' must not be empty");
-  }
-  const raw = await embeddingAdapter.embed(params.vector.text, "query", signal);
-  if (!(raw instanceof Float32Array)) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_FAILED,
-      `Adapter returned ${typeof raw} for query embedding, expected Float32Array`
-    );
-  }
-  if (raw.length !== embeddingAdapter.dimensions) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_DIMENSION_MISMATCH,
-      `Adapter returned ${raw.length}-dimensional vector for query, expected ${embeddingAdapter.dimensions}`,
-      { expected: embeddingAdapter.dimensions, actual: raw.length }
-    );
-  }
-  const resolved = { ...params.vector, value: Array.from(raw) };
-  delete resolved.text;
-  return { ...params, vector: resolved };
-}
-
-// src/engine/suggest.ts
-var DEFAULT_SUGGEST_LIMIT = 10;
-var MAX_SUGGEST_LIMIT = 100;
-var SUGGEST_OVERSAMPLE_FACTOR = 1.5;
-var SUGGEST_OVERSAMPLE_PADDING = 10;
-var MAX_SUGGEST_SCATTER_LIMIT = Math.ceil(MAX_SUGGEST_LIMIT * SUGGEST_OVERSAMPLE_FACTOR) + SUGGEST_OVERSAMPLE_PADDING;
-function executeSuggest(manager, language, params, partitionIds) {
-  const t0 = performance.now();
-  const ceiling = partitionIds === void 0 ? MAX_SUGGEST_LIMIT : MAX_SUGGEST_SCATTER_LIMIT;
-  const limit = Math.max(1, Math.min(clampRowCount(params.limit, DEFAULT_SUGGEST_LIMIT), ceiling));
-  const rawPrefix = params.prefix.trim();
-  if (rawPrefix.length === 0) {
-    return { terms: [], elapsed: performance.now() - t0 };
-  }
-  const unstemmed = tokenize(rawPrefix, language, { stem: false, removeStopWords: false });
-  const lastToken = unstemmed.tokens.length > 0 ? unstemmed.tokens[unstemmed.tokens.length - 1].token : rawPrefix.toLowerCase();
-  if (lastToken.length === 0) {
-    return { terms: [], elapsed: performance.now() - t0 };
-  }
-  const stemmed = language.stemmer ? language.stemmer(lastToken) : lastToken;
-  const merged = /* @__PURE__ */ new Map();
-  const perPartitionLimit = limit * 2;
-  const partitions = partitionIds === void 0 ? manager.getAllPartitions() : partitionIds.map((partitionId) => manager.partitionAt(partitionId)).filter((partition) => partition !== void 0);
-  for (const partition of partitions) {
-    for (const suggestion of partition.suggestTerms(lastToken, stemmed, perPartitionLimit)) {
-      let entry = merged.get(suggestion.token);
-      if (!entry) {
-        entry = { documentFrequency: 0, surfaceOccurrences: /* @__PURE__ */ new Map() };
-        merged.set(suggestion.token, entry);
-      }
-      entry.documentFrequency += suggestion.documentFrequency;
-      for (const s of suggestion.surfaces) {
-        entry.surfaceOccurrences.set(s.surface, (entry.surfaceOccurrences.get(s.surface) ?? 0) + s.occurrences);
-      }
-    }
-  }
-  const terms = Array.from(merged.values()).map((entry) => ({ term: pickDisplaySurface(entry.surfaceOccurrences), documentFrequency: entry.documentFrequency })).sort((a, b) => b.documentFrequency - a.documentFrequency || compareCodePoints(a.term, b.term));
-  if (terms.length > limit) terms.length = limit;
-  return { terms, elapsed: performance.now() - t0 };
-}
-function pickDisplaySurface(surfaceOccurrences) {
-  let best = "";
-  let bestCount = -1;
-  for (const [surface, occurrences] of surfaceOccurrences) {
-    if (occurrences > bestCount || occurrences === bestCount && compareCodePoints(surface, best) < 0) {
-      best = surface;
-      bestCount = occurrences;
-    }
-  }
-  return best;
-}
-
 // src/narsil/reads.ts
 function scopedParams(params, options) {
   if (options?.globalStats === void 0) {
@@ -9912,7 +9224,7 @@ async function runEngineQuery(core, indexName, params, options) {
       entry.embeddingAdapterName
     );
     await core.pluginRegistry.runHook("beforeSearch", { indexName, params: resolvedParams });
-    const workerSearch = core.orchestrator.isPromoted() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
+    const workerSearch = core.orchestrator.hasWorkerPool() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
     const result = await executeQuery(resolvedParams, {
       manager,
       language: entry.language,
@@ -9952,7 +9264,7 @@ async function runEnginePreflight(core, indexName, params, options) {
       core.abortController.signal,
       entry.embeddingAdapterName
     );
-    const workerSearch = core.orchestrator.isPromoted() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
+    const workerSearch = core.orchestrator.hasWorkerPool() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
     const result = await executePreflight(resolvedParams, {
       manager,
       language: entry.language,
@@ -10115,17 +9427,22 @@ function createNarsilFromCore(core, config) {
     insertBatch(indexName, documents, options) {
       return withOpenIndex(indexName, () => insertDocumentBatch(mutationCtx, indexName, documents, options));
     },
-    remove(indexName, docId) {
-      return withOpenIndex(indexName, () => removeDocument(mutationCtx, indexName, docId));
+    remove(indexName, docId, options) {
+      return withOpenIndex(indexName, () => removeDocument(mutationCtx, indexName, docId, options));
+    },
+    removeBatch(indexName, docIds, options) {
+      return withOpenIndex(indexName, () => removeDocumentBatch(mutationCtx, indexName, docIds, options));
     },
-    removeBatch(indexName, docIds) {
-      return withOpenIndex(indexName, () => removeDocumentBatch(mutationCtx, indexName, docIds));
+    update(indexName, docId, document, options) {
+      return withOpenIndex(indexName, () => updateDocument(mutationCtx, indexName, docId, document, options));
     },
-    update(indexName, docId, document) {
-      return withOpenIndex(indexName, () => updateDocument(mutationCtx, indexName, docId, document));
+    updateBatch(indexName, updates, options) {
+      return withOpenIndex(indexName, () => updateDocumentBatch(mutationCtx, indexName, updates, options));
     },
-    updateBatch(indexName, updates) {
-      return withOpenIndex(indexName, () => updateDocumentBatch(mutationCtx, indexName, updates));
+    waitForWrites(indexName) {
+      guardShutdown();
+      requireIndex(indexName);
+      return orchestrator.awaitWrites(indexName);
     },
     async get(indexName, docId) {
       return withOpenIndex(indexName, () => executor.execute({ type: "get", indexName, docId, requestId: docId }));
@@ -10189,6 +9506,7 @@ function createNarsilFromCore(core, config) {
         clearAnalysisStale: core.analysisRebuild.clearStale,
         indexState: core.indexState
       });
+      core.heapPressureNotifier.check(indexName);
     },
     async checkpoint(indexName) {
       guardShutdown();
@@ -10268,6 +9586,7 @@ function createNarsilFromCore(core, config) {
         openIndexCount: lifecycleCounts.open,
         closedIndexCount: lifecycleCounts.closed,
         reopenCount: lifecycleCounts.reopens,
+        workerCopies: orchestrator.workerCopies(),
         workers
       };
     },
@@ -10313,6 +9632,7 @@ function createNarsilFromCore(core, config) {
       await shutdownEngine(core);
     }
   };
+  bindEngineCore(narsil, core);
   return narsil;
 }
 
@@ -10321,6 +9641,7 @@ async function createNarsil(config) {
   const core = createEngineCore(config);
   if (core.durability) {
     await core.durability.manager.recover(config?.lifecycle !== void 0);
+    checkHeapAfterRecovery(core);
   }
   if (core.invalidation) {
     await core.invalidation.start();
@@ -10332,4 +9653,4 @@ async function createNarsil(config) {
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, VERSION, WIRE_BATCH_BUDGET, applyDeleteEntry, applyIndexEntry, chunkByBudget, clampLimit, computeEntryChecksum, createAckMessage, createDurableDirectory, createEngineCore, createEngineIndex, createEntryBatchMessage, createEntryMessage, createForwardBatchMessage, createForwardBatchResultMessage, createForwardMessage, createInsyncAddMessage, createInsyncConfirmMessage, createInsyncRemoveMessage, createNarsil, createNarsilFromCore, dedupePinnedEntries, foldGroupReducer, listBindingOf, now, queryBindingOf, runEngineListDocuments, runEnginePreflight, runEngineQuery, runEngineQueryStats, runEngineSuggest, validateAckPayload, validateEntryBatchPayload, validateEntryPayload, validateForwardBatchPayload, validateForwardBatchResultPayload, validateInsyncConfirmPayload, validateReplicationEntry, writeSegmentedCheckpoint };
+export { VERSION, applyDeleteEntry, applyIndexEntry, checkHeapAfterRecovery, computeEntryChecksum, createAckMessage, createDurableDirectory, createEngineCore, createEngineIndex, createEntryBatchMessage, createEntryMessage, createForwardBatchMessage, createForwardBatchResultMessage, createForwardMessage, createInsyncAddMessage, createInsyncConfirmMessage, createInsyncRemoveMessage, createNarsil, createNarsilFromCore, runEngineListDocuments, runEnginePreflight, runEngineQuery, runEngineQueryStats, runEngineSuggest, validateAckPayload, validateEntryBatchPayload, validateEntryPayload, validateForwardBatchPayload, validateForwardBatchResultPayload, validateInsyncConfirmPayload, validateReplicationEntry, writeSegmentedCheckpoint };