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

package/dist/{chunk-56PJBIJ6.mjs → chunk-ND34I3SV.mjs}

@@ -1,9 +1,13 @@
+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, DEFAULT_LIMIT, MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, STATISTICS_BROADCAST_INTERVAL_MS, MAX_SWEEP_INTERVAL_MS, DEFAULT_OFFSET, MIN_SWEEP_INTERVAL_MS, FOREIGN_STATS_TTL_MS, MIN_DOCUMENTS_FOR_SEGMENTS, BATCH_CHUNK_SIZE, MAX_DOC_ID_LENGTH } from './chunk-OWCFK42Q.mjs';
-import { getNestedValue, getLanguage, extractVectorFieldsFromSchema, clampRowCount, splitWorkerBudget, resolveWorkerCount, createDirectExecutor, createPartitionRouter, validateSchema, validateVectorPromotion, collectQueryTermStats, createPartitionManager, createVectorIndex, detectRuntime, 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, partitionsIn, isNodeMainThread, spawnNodeWorker, CHECKSUM_TIMEOUT_MS, CHECKSUM_YIELD_CHUNK_BYTES, createSharedFrozenSegment, buildCompactedSegmentPayload, freezeSegmentShared, createFrozenSegment, isCompositePartition, deserializeMetadata, serializeMetadata, createWorkerPool, WORKER_RESOURCE_LIMITS, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, SHUTDOWN_TIMEOUT_MS, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, encodeSegmentState, validateRequiredFields, kWayMerge, validateDocument, validateDocumentStrict } from './chunk-M6JGMKA5.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-2GWVQWGA.mjs';
-import { generateId, createRequestId, isValidWorkerResponse } from './chunk-RDGXYRF4.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';
 
@@ -272,6 +276,20 @@ function validateRequiredFieldsInSchema(required, schema) {
   }
 }
 
+// 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 handlers.size;
+}
+
 // src/engine/analysis-rebuild.ts
 function yieldToEventLoop() {
   return new Promise((resolve) => {
@@ -293,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);
     }
   });
 }
@@ -827,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
@@ -836,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();
@@ -1447,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") {
@@ -1467,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);
@@ -5165,6 +5175,94 @@ 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) {
@@ -5245,10 +5343,17 @@ async function sendPartition(indexName, executors, captured) {
     )
   );
 }
-async function transferIndexToPool(indexName, pool, config, manager) {
-  await loadIndexOntoWorkers(indexName, pool.getAllExecutors(), config, manager, () => pool.addIndexToAll(indexName));
+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) {
+async function loadIndexOntoWorkers(indexName, executors, config, manager, onDropped, analysisStale = false) {
   const captured = capturePartitions(manager);
   await Promise.allSettled(
     executors.map(
@@ -5262,7 +5367,8 @@ async function loadIndexOntoWorkers(indexName, executors, config, manager, onDro
         type: "createIndex",
         indexName,
         config,
-        requestId: `resync-create-${indexName}`
+        requestId: `resync-create-${indexName}`,
+        analysisStale
       })
     )
   );
@@ -5519,15 +5625,37 @@ function queueForCopies(state, action) {
   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 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;
   }
 }
 
@@ -5770,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);
     }
@@ -5795,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() {
@@ -5844,9 +5973,10 @@ async function createWorkerFactory(entryPoint) {
   const resolvedEntry = resolveEntryPoint();
   if (runtime.supportsWorkerThreads) {
     const workerThreadsModule = await import('worker_threads');
-    return function nodeFactory(_workerId, onDeath) {
+    return function nodeFactory(workerId, onDeath) {
       const instance = new workerThreadsModule.Worker(new URL(resolvedEntry), {
-        resourceLimits: WORKER_RESOURCE_LIMITS
+        resourceLimits: WORKER_RESOURCE_LIMITS,
+        workerData: { workerId }
       });
       return createWorkerExecutor(instance, { onDeath });
     };
@@ -5860,6 +5990,105 @@ async function createWorkerFactory(entryPoint) {
   throw new NarsilError(ErrorCodes.WORKER_CRASHED, `No worker support available on runtime "${runtime.runtime}"`);
 }
 
+// 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()
+      });
+    }
+  };
+}
+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));
+    }
+  }
+  return pool.workerCount;
+}
+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) {
@@ -5878,10 +6107,13 @@ function retirePool(state, pool) {
   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;
@@ -5909,12 +6141,20 @@ async function loadOntoReplacement(state, replacement, indexName) {
   const buffered = [];
   state.copyLoadBuffers.set(indexName, buffered);
   try {
-    await loadIndexOntoWorkers(indexName, [replacement.executor], entry.config, manager);
+    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);
@@ -5931,6 +6171,7 @@ async function replaceWorker(state, pool, workerId) {
       await loadOntoReplacement(state, replacement, indexName);
     }
     replacement.admit();
+    await state.requestThreads?.onWorkerReady(workerId, replacement.executor);
   } catch (err) {
     replacement.abandon();
     throw err;
@@ -5960,7 +6201,7 @@ function repairPool(state, pool) {
 // 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) return false;
+  if (!state.workersEnabled || state.scaleOutBlocked || state.shuttingDown) return false;
   return state.workerPool !== null || Date.now() >= state.poolRetryAt;
 }
 async function startPool(state) {
@@ -5995,9 +6236,15 @@ async function ensurePool(state) {
   if (state.workerPool !== null) return state.workerPool;
   if (state.poolStart === null) {
     state.poolStart = startPool(state).then(
-      (pool) => {
+      async (pool) => {
         state.workerPool = pool;
         state.poolStart = null;
+        try {
+          await announceRequestThreads(state, pool);
+        } catch (err) {
+          retirePool(state, pool);
+          throw err;
+        }
         return pool;
       },
       (err) => {
@@ -6046,7 +6293,7 @@ async function loadCopies(state, indexName, reason) {
   const buffered = [];
   state.copyLoadBuffers.set(indexName, buffered);
   try {
-    await transferIndexToPool(indexName, pool, entry.config, manager);
+    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;
@@ -6058,6 +6305,7 @@ async function loadCopies(state, indexName, reason) {
     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);
 }
@@ -6219,7 +6467,7 @@ async function runSplit(leases, scope, indexName, params, globalStats) {
   return mergeWorkerResults(results);
 }
 function takeMainCopyTurn(state) {
-  if (state.mainCopyTurnTaken) return false;
+  if (state.mainCopyQueries === "none" || state.mainCopyTurnTaken) return false;
   state.mainCopyTurnTaken = true;
   afterCurrentTurn(() => {
     state.mainCopyTurnTaken = false;
@@ -6235,8 +6483,6 @@ async function searchViaWorker(state, indexName, params, globalStats, partitionI
   const pool = state.workerPool;
   if (!pool) return null;
   if (!state.scaledOutIndexes.has(indexName) || state.copyLoadBuffers.has(indexName)) return null;
-  const pendingReplication = state.replicationQueues.get(indexName);
-  if (pendingReplication !== void 0 && pendingReplication.pendingActions > 0) return null;
   const manager = state.executor.getManager(indexName);
   if (!manager) return null;
   if (answersFasterOnMainCopy(state, pool, manager)) return null;
@@ -6286,14 +6532,16 @@ function workersEnabledByDefault() {
 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) {
+function createWorkerOrchestrator(config, executor, indexRegistry, callbacks, vectorCopyPolicy) {
   const state = {
     config,
     executor,
     indexRegistry,
     callbacks,
+    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,
@@ -6315,8 +6563,10 @@ function createWorkerOrchestrator(config, executor, indexRegistry, callbacks) {
     poolRetryDelayMs: POOL_RESTART_DELAY_MS,
     poolRepair: null,
     mainCopyTurnTaken: false,
+    mainCopyQueries: config?.workers?.mainCopyQueries,
     repairTimer: null,
     scaleOutBlocked: false,
+    shuttingDown: false,
     idleSweep: null
   };
   startIdleSweep(state);
@@ -6337,6 +6587,7 @@ function createWorkerOrchestrator(config, executor, indexRegistry, callbacks) {
       workerId: report.workerId,
       heapUsed: report.heapUsed,
       heapTotal: report.heapTotal,
+      heapLimit: report.heapLimit,
       external: report.external
     }));
   }
@@ -6352,8 +6603,10 @@ function createWorkerOrchestrator(config, executor, indexRegistry, callbacks) {
     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;
@@ -6374,8 +6627,9 @@ function createWorkerOrchestrator(config, executor, indexRegistry, callbacks) {
     const manager = executor.getManager(indexName);
     if (pool !== null && entry !== void 0 && manager !== void 0) {
       try {
-        await transferIndexToPool(indexName, pool, entry.config, manager);
+        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,
@@ -6394,6 +6648,16 @@ function createWorkerOrchestrator(config, executor, indexRegistry, callbacks) {
       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) {
     if (state.poolRepair !== null) await state.poolRepair;
     const transition = state.copyTransitions.get(indexName);
@@ -6431,6 +6695,7 @@ function createWorkerOrchestrator(config, executor, indexRegistry, callbacks) {
     scaleOutBeforeBatch: (indexName, incomingCount) => scaleOutBeforeBatch(state, indexName, incomingCount),
     replicateToWorkers: replicate,
     awaitReplication: (indexName) => awaitReplicationIdle(state, indexName),
+    awaitWrites: (indexName) => awaitWritesApplied(state, indexName),
     awaitCompactions: () => awaitCompactions(state),
     openIndex,
     closeIndex,
@@ -6439,9 +6704,19 @@ function createWorkerOrchestrator(config, executor, indexRegistry, callbacks) {
     segmentBuildConcurrency: (indexName) => segmentBuildConcurrency(state, indexName),
     searchViaWorker: (indexName, params, globalStats, partitionIds) => searchViaWorker(state, indexName, params, globalStats, partitionIds),
     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);
-      return state.scaledOutIndexes.delete(indexName);
+      const wasScaledOut = state.scaledOutIndexes.delete(indexName);
+      if (wasScaledOut) withdrawCopies(indexName);
+      return wasScaledOut;
     },
     resyncIndex,
     noteAccess: (indexName) => noteAccess(state, indexName),
@@ -6451,160 +6726,20 @@ function createWorkerOrchestrator(config, executor, indexRegistry, callbacks) {
   };
 }
 
-// src/engine/validation.ts
-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 });
-  }
-}
-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 requirePositiveSafeInteger(field, value) {
-  if (value === void 0) return;
-  if (!Number.isSafeInteger(value) || value < 1) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, `${field} must be a positive safe integer`, { field, value });
-  }
-}
-function validateWorkerConfig(workers, lifecycle) {
-  if (workers === void 0) return;
-  requirePositiveSafeInteger("workers.count", workers.count);
-  requirePositiveSafeInteger("workers.promotionThreshold", workers.promotionThreshold);
-  requirePositiveSafeInteger("workers.idleTimeoutMs", workers.idleTimeoutMs);
-  const closeAfter = lifecycle?.idleTimeoutMs;
-  if (workers.idleTimeoutMs !== void 0 && closeAfter !== void 0 && workers.idleTimeoutMs > closeAfter) {
-    throw new NarsilError(
-      ErrorCodes.CONFIG_INVALID,
-      "workers.idleTimeoutMs must be at most lifecycle.idleTimeoutMs, so that an index drops its copies before it closes",
-      { workersIdleTimeoutMs: workers.idleTimeoutMs, lifecycleIdleTimeoutMs: closeAfter }
-    );
-  }
-}
-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/vector-fields.ts
 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) {
   validateWorkerConfig(config?.workers, config?.lifecycle);
   const vectorWorkerCount = splitWorkerBudget(resolveWorkerCount(config?.workers?.count)).vector;
-  const executor = createDirectExecutor({
-    vectorWorkerCopies: {
-      enabled: (config?.workers?.enabled ?? workersEnabledByDefault()) && vectorWorkerCount > 0,
-      count: vectorWorkerCount
-    }
-  });
+  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);
@@ -6622,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, indexRegistry, {
-    shouldDeferCopies() {
-      return rebalancingIndexes.size > 0;
-    },
-    onCopiesLoaded(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));
-      });
-    },
-    onCopyLoadFailure(reason, error, retryable) {
-      const handlers = eventHandlers.get("workerPromoteFailure");
-      if (!handlers || handlers.size === 0) {
-        console.warn(`Loading worker copies 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();
@@ -6760,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) {
@@ -6786,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,
@@ -6827,7 +6950,10 @@ 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 = {
@@ -6841,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,
@@ -6881,6 +7009,7 @@ function createEngineCore(config, hooks) {
     requireManager,
     bufferIfRebalancing,
     watermarkNotifier,
+    heapPressureNotifier,
     analysisRebuild,
     indexState,
     mutationCtx,
@@ -7391,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();
@@ -7476,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 {
@@ -7498,7 +7635,9 @@ async function insertDocument(ctx, indexName, document, docId, options) {
     }
   }
   ctx.checkWatermark(indexName);
+  ctx.checkHeapPressure(indexName);
   await ctx.orchestrator.scaleOutReadyIndexes();
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
   return resolvedDocId;
 }
 
@@ -7911,7 +8050,9 @@ async function insertBatchViaSegments(ctx, indexName, documents, options) {
     vecIndexes.get(fieldPath)?.scheduleBuild();
   }
   ctx.checkWatermark(indexName);
+  ctx.checkHeapPressure(indexName);
   await ctx.orchestrator.scaleOutReadyIndexes();
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
   return { succeeded: outcome.succeeded, failed };
 }
 
@@ -8073,12 +8214,14 @@ async function insertDocumentBatch(ctx, indexName, documents, options) {
     }
   }
   ctx.checkWatermark(indexName);
+  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);
@@ -8117,6 +8260,7 @@ async function removeDocument(ctx, indexName, docId) {
     await applyRemove();
   }
   if (buffered) {
+    if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
     return;
   }
   try {
@@ -8130,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 = [];
@@ -8159,6 +8304,7 @@ async function removeDocumentBatch(ctx, indexName, docIds) {
   } finally {
     manager.endBatchRemove();
   }
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
   return { succeeded, failed };
 }
 
@@ -8176,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);
@@ -8278,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 {
@@ -8304,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 = [];
@@ -8344,6 +8494,7 @@ async function updateDocumentBatch(ctx, indexName, updates) {
       vecIndex.scheduleBuild();
     }
   }
+  if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
   return { succeeded, failed };
 }
 
@@ -8352,6 +8503,10 @@ 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) {
@@ -8378,6 +8533,12 @@ function createWriteAheadQueue(maxSize = DEFAULT_WRITE_AHEAD_QUEUE_MAX_SIZE) {
     bufferedDocState(docId) {
       return docStates.get(docId);
     },
+    whenReplayed() {
+      return replayed;
+    },
+    markReplayed() {
+      resolveReplayed();
+    },
     get size() {
       return entries.length;
     },
@@ -8551,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 {
@@ -8596,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);
 }
@@ -9023,6 +9184,7 @@ function readProcessMemory() {
     return {
       heapUsed: usage.heapUsed,
       heapTotal: usage.heapTotal,
+      heapLimit: readHeapStatistics()?.limitBytes ?? null,
       external: usage.external,
       rss: usage.rss
     };
@@ -9031,1204 +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
-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) {
@@ -10463,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 }));
@@ -10537,6 +9506,7 @@ function createNarsilFromCore(core, config) {
         clearAnalysisStale: core.analysisRebuild.clearStale,
         indexState: core.indexState
       });
+      core.heapPressureNotifier.check(indexName);
     },
     async checkpoint(indexName) {
       guardShutdown();
@@ -10662,6 +9632,7 @@ function createNarsilFromCore(core, config) {
       await shutdownEngine(core);
     }
   };
+  bindEngineCore(narsil, core);
   return narsil;
 }
 
@@ -10670,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();
@@ -10681,4 +9653,4 @@ async function createNarsil(config) {
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { VERSION, applyDeleteEntry, applyIndexEntry, 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 };