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

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

@@ -1,14 +1,17 @@
-import { ReplicationMessageTypes } from './chunk-JQUL2T6I.mjs';
-import { MAX_INDEX_NAME_LENGTH } from './chunk-XWICBGYT.mjs';
-import { getNestedValue, getLanguage, extractVectorFieldsFromSchema, createDirectExecutor, createPartitionRouter, clampRowCount, DEFAULT_PAGE_SIZE, validateSchema, validateVectorPromotion, collectQueryTermStats, createPartitionManager, createVectorIndex, flattenSchema, isTextFieldType, fnv1aBytes, requireWithinResultWindow, normalizeSort, sortSignatureOf, requireSortableFields, fanOutQuery, applySorting, applyPagination, resolveProjection, countsWithoutScores, fanOutMatchCount, tokenize, decodePageCursor, requireMatchingCursor, encodePageCursor, resolveIndexAnalysis, deserializePayloadV2, deserializePayloadV1, mergePartitionStats, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, createPartitionIndex, fnv1a, createWorkerPool, partitionsIn, detectRuntime, isNodeMainThread, spawnNodeWorker, createSharedFrozenSegment, buildCompactedSegmentPayload, freezeSegmentShared, createFrozenSegment, deserializeMetadata, isCompositePartition, serializeMetadata, kWayMerge, validateRequiredFields, validateDocument, validateDocumentStrict } from './chunk-EV45L35L.mjs';
+import { 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 { crc32, crc32Init, crc32Update, crc32Final } from './chunk-KMMJMDUA.mjs';
-import { compareCodePoints, compareComparableKeys } from './chunk-BFIH7OV5.mjs';
-import { generateId, createRequestId, isValidWorkerResponse } from './chunk-WTONLDU3.mjs';
+import { compareCodePoints, compareComparableKeys } from './chunk-2GWVQWGA.mjs';
+import { generateId, createRequestId, isValidWorkerResponse } from './chunk-RDGXYRF4.mjs';
 import { ErrorCodes, NarsilError } from './chunk-P4ELXVJQ.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
+// src/partitioning/constants.ts
+var REBALANCE_CHUNK_SIZE = 1e3;
+var DEFAULT_WRITE_AHEAD_QUEUE_MAX_SIZE = 1e4;
+
 // src/partitioning/rebalancer.ts
-var CHUNK_SIZE = 1e3;
 function createRebalancer() {
   const activeManagers = /* @__PURE__ */ new WeakSet();
   let activeCount = 0;
@@ -71,7 +74,7 @@ function createRebalancer() {
             documentsProcessed++;
           }
           chunkFill++;
-          if (chunkFill >= CHUNK_SIZE) {
+          if (chunkFill >= REBALANCE_CHUNK_SIZE) {
             chunkFill = 0;
             onProgress?.({
               phase: "moving",
@@ -269,44 +272,6 @@ function validateRequiredFieldsInSchema(required, schema) {
   }
 }
 
-// src/workers/promoter.ts
-var DEFAULT_PER_INDEX_THRESHOLD = 1e4;
-var DEFAULT_TOTAL_THRESHOLD = 5e4;
-function createExecutionPromoter(config) {
-  const perIndexThreshold = config?.perIndexThreshold ?? DEFAULT_PER_INDEX_THRESHOLD;
-  const totalThreshold = config?.totalThreshold ?? DEFAULT_TOTAL_THRESHOLD;
-  let promoted = false;
-  function check(indexes) {
-    if (promoted) {
-      return { shouldPromote: false, reason: "" };
-    }
-    let totalDocuments = 0;
-    for (const [indexName, stats] of indexes) {
-      if (stats.documentCount >= perIndexThreshold) {
-        return {
-          shouldPromote: true,
-          reason: `Index "${indexName}" has ${stats.documentCount} documents, exceeding the per-index threshold of ${perIndexThreshold}`
-        };
-      }
-      totalDocuments += stats.documentCount;
-    }
-    if (totalDocuments >= totalThreshold) {
-      return {
-        shouldPromote: true,
-        reason: `Total document count of ${totalDocuments} exceeds the total threshold of ${totalThreshold}`
-      };
-    }
-    return { shouldPromote: false, reason: "" };
-  }
-  function markPromoted() {
-    promoted = true;
-  }
-  function isPromoted() {
-    return promoted;
-  }
-  return { check, markPromoted, isPromoted };
-}
-
 // src/engine/analysis-rebuild.ts
 function yieldToEventLoop() {
   return new Promise((resolve) => {
@@ -383,7 +348,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
       throw error;
     }
   }
-  function enqueue2(indexName, entry) {
+  function enqueue(indexName, entry) {
     if (entry.run !== null) {
       return entry.run;
     }
@@ -397,7 +362,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
   }
   async function announce(indexName, entry) {
     const documentCount = deps.getManager(indexName)?.countDocuments() ?? 0;
-    await config?.onStaleAnalysis?.({ ...entry.index, documentCount }, () => enqueue2(indexName, entry));
+    await config?.onStaleAnalysis?.({ ...entry.index, documentCount }, () => enqueue(indexName, entry));
   }
   async function review(indexName, entry) {
     if (entry.run !== null || deps.getManager(indexName) === void 0) return;
@@ -413,7 +378,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
       });
     }
     if (rebuildMode === "auto") {
-      void enqueue2(indexName, entry).catch(() => void 0);
+      void enqueue(indexName, entry).catch(() => void 0);
     }
   }
   return {
@@ -447,7 +412,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
       if (entry === void 0) {
         return Promise.resolve();
       }
-      return enqueue2(indexName, entry);
+      return enqueue(indexName, entry);
     }
   };
 }
@@ -532,6 +497,15 @@ function resolveDurabilityTier(config) {
   return { kind: "snapshot", config: {}, adapter: config.persistence };
 }
 
+// src/persistence/durability/constants.ts
+var DEFAULT_CHECKPOINT_INTERVAL_MS = 3e5;
+var DEFAULT_CHECKPOINT_MUTATION_THRESHOLD = 1e5;
+var DEFAULT_ASYNC_FLUSH_INTERVAL_MS = 1e3;
+var DEFAULT_SEGMENT_MAX_BYTES = 67108864;
+var DEFAULT_COMPACTION_THRESHOLD = 12;
+var CHECKPOINT_WORKER_TIMEOUT_MS = 6e5;
+var CHECKPOINT_TIMEOUT_RECOVERY_BACKOFF_MS = 50;
+
 // src/persistence/durability/node-fs.ts
 var cachedFs = null;
 var cachedPath = null;
@@ -809,8 +783,6 @@ function buildEntry(fields) {
 }
 
 // src/serialization/checksum-dispatch.ts
-var CHECKSUM_TIMEOUT_MS = 12e4;
-var YIELD_CHUNK_BYTES = 4 * 1024 * 1024;
 var workerUsable = true;
 var mainThreadResolved = false;
 var onMainThread = true;
@@ -844,8 +816,8 @@ function yieldToEventLoop2() {
 }
 async function chunkedChecksum(payload) {
   let state = crc32Init();
-  for (let offset = 0; offset < payload.length; offset += YIELD_CHUNK_BYTES) {
-    const end = Math.min(offset + YIELD_CHUNK_BYTES, payload.length);
+  for (let offset = 0; offset < payload.length; offset += CHECKSUM_YIELD_CHUNK_BYTES) {
+    const end = Math.min(offset + CHECKSUM_YIELD_CHUNK_BYTES, payload.length);
     state = crc32Update(state, payload.subarray(offset, end));
     if (end < payload.length) {
       await yieldToEventLoop2();
@@ -1437,8 +1409,6 @@ function formatSegmentStart(startSeqNo) {
 }
 
 // src/persistence/durability/checkpoint-worker-dispatch.ts
-var CHECKPOINT_WORKER_TIMEOUT_MS = 6e5;
-var TIMEOUT_RECOVERY_BACKOFF_MS = 50;
 var workerUsable2 = true;
 var pooledWorker = null;
 var workerBusy = false;
@@ -1551,7 +1521,7 @@ async function runCheckpointOnWorker(request) {
       return true;
     }
     if (outcome.timedOut) {
-      await delay(TIMEOUT_RECOVERY_BACKOFF_MS);
+      await delay(CHECKPOINT_TIMEOUT_RECOVERY_BACKOFF_MS);
     }
     return false;
   } finally {
@@ -1571,7 +1541,6 @@ function terminateCheckpointWorker() {
 }
 
 // src/persistence/durability/segment/layout.ts
-var DEFAULT_COMPACTION_THRESHOLD = 12;
 var SEGMENT_ID_WIDTH = 16;
 function manifestKey(indexName) {
   return `${indexName}/manifest`;
@@ -2513,37 +2482,6 @@ function setNestedValue(obj, path, value) {
   }
   current[finalSegment] = value;
 }
-
-// src/distribution/chunking.ts
-var WIRE_BATCH_BUDGET = {
-  maxCount: 1e3,
-  maxBytes: 8388608,
-  overheadBytes: 256
-};
-function chunkByBudget(items, budget) {
-  const chunks = [];
-  let current = [];
-  let currentBytes = 0;
-  for (const item of items) {
-    const itemBytes = budget.payloadBytesOf(item) + budget.overheadBytes;
-    const previous = current[current.length - 1];
-    const breaksRun = previous !== void 0 && budget.breaksRun?.(item, previous) === true;
-    const overflows = current.length >= budget.maxCount || current.length > 0 && currentBytes + itemBytes > budget.maxBytes;
-    if (breaksRun || overflows) {
-      chunks.push(current);
-      current = [];
-      currentBytes = 0;
-    }
-    current.push(item);
-    currentBytes += itemBytes;
-  }
-  if (current.length > 0) {
-    chunks.push(current);
-  }
-  return chunks;
-}
-
-// src/distribution/replication/codec.ts
 function createEntryMessage(entry, sourceId) {
   const payload = { entry };
   return {
@@ -3266,7 +3204,10 @@ async function writePartitionVectors(input) {
   }
   const vectorIndexes = /* @__PURE__ */ new Map();
   for (const [fieldPath, dimension] of input.vectorFields) {
-    vectorIndexes.set(fieldPath, createVectorIndex(fieldPath, dimension, input.config.vectorPromotion));
+    vectorIndexes.set(
+      fieldPath,
+      createVectorIndex(fieldPath, dimension, input.config.vectorPromotion, { enabled: false })
+    );
   }
   for (const ref of input.priorVectors) {
     const vecIndex = vectorIndexes.get(ref.fieldPath);
@@ -3684,11 +3625,6 @@ async function recoverPersistedIndex(deps, indexName, metadataOnly) {
   }
 }
 
-// src/persistence/durability/types.ts
-var DEFAULT_CHECKPOINT_INTERVAL_MS = 3e5;
-var DEFAULT_CHECKPOINT_MUTATION_THRESHOLD = 1e5;
-var DEFAULT_ASYNC_FLUSH_INTERVAL_MS = 1e3;
-
 // src/persistence/durability/group-commit.ts
 function createGroupCommitCoordinator(sync) {
   let inFlight = null;
@@ -3762,7 +3698,6 @@ async function createMarkerWriter(directory, indexName, partitionId) {
 }
 
 // src/persistence/durability/wal-writer.ts
-var DEFAULT_SEGMENT_MAX_BYTES = 67108864;
 var SEGMENT_TAIL_PATTERN = /^\d{16}$/;
 function segmentKey2(indexName, partitionId, startSeqNo) {
   const padded = startSeqNo.toString().padStart(16, "0");
@@ -4680,11 +4615,11 @@ function createDurabilityFromTier(tier, wiring) {
   });
 }
 
-// src/engine/index-state/entry.ts
+// src/engine/index-state/constants.ts
 var DEFAULT_MAX_REOPEN_WAITERS = 64;
 var MAX_REOPEN_FAILURES = 5;
-var MIN_SWEEP_INTERVAL_MS = 100;
-var MAX_SWEEP_INTERVAL_MS = 6e4;
+
+// src/engine/index-state/entry.ts
 function createLifecycleEntry(state) {
   return {
     state,
@@ -4958,7 +4893,10 @@ function createIndexStateCoordinator(config, callbacks) {
         await reopen(indexName, false);
         entry = entryOf(indexName);
       }
-      if (markActive) entry.lastAccessAt = Date.now();
+      if (markActive) {
+        entry.lastAccessAt = Date.now();
+        callbacks.onAccess?.(indexName);
+      }
       entry.activeOperations += 1;
       try {
         if (opened) await enforceLimits(indexName);
@@ -5061,6 +4999,9 @@ function wireIndexState(wiring) {
         }
       }
     },
+    onAccess(indexName) {
+      wiring.onAccess?.(indexName);
+    },
     canCloseAutomatically(indexName) {
       return !rebalancingIndexes.has(indexName) && !analysisRebuild.isRunning(indexName) && !orchestrator.isIndexBusy(indexName);
     },
@@ -5071,8 +5012,6 @@ function wireIndexState(wiring) {
 }
 
 // src/engine/invalidation.ts
-var STATISTICS_BROADCAST_INTERVAL_MS = 5e3;
-var FOREIGN_STATS_TTL_MS = 6e4;
 function createInvalidationFromConfig(config, tierKind, deps) {
   if (config?.invalidation === void 0) {
     return null;
@@ -5226,17 +5165,99 @@ function createInvalidationIntegration(deps) {
   };
 }
 
+// src/core/partition/frozen/share.ts
+function shareFrozenSegment(segment) {
+  if (segment.sharedSnapshot !== null) {
+    return { snapshot: segment.sharedSnapshot, tombstonedDocIds: segment.tombstonedDocIds() };
+  }
+  const payload = encodeSegmentState(segment);
+  const documents = payload.docIds.map((docId) => {
+    const stored = segment.docStore.get(docId);
+    if (stored === void 0) {
+      throw new NarsilError(ErrorCodes.PARTITION_CORRUPTED, `Document "${docId}" vanished while sharing a segment`, {
+        docId
+      });
+    }
+    return stored.fields;
+  });
+  const snapshot = freezeSegmentShared(payload, documents, segment.segmentId);
+  return snapshot === null ? null : { snapshot, tombstonedDocIds: [] };
+}
+
 // src/engine/worker-resync.ts
+function captureComposite(manager, partitionId) {
+  const partition = manager.getPartition(partitionId);
+  if (!isCompositePartition(partition)) return null;
+  const segmentIds = partition.frozenSegmentSizes().map((size) => size.segmentId);
+  const frozen = [];
+  for (const segment of partition.frozenSegmentsById(segmentIds)) {
+    const shared = shareFrozenSegment(segment);
+    if (shared === null) return null;
+    frozen.push(shared);
+  }
+  const live = partition.live.serialize(
+    manager.indexName,
+    manager.partitionCount,
+    manager.language.name,
+    manager.schema
+  );
+  return { partitionId, live, frozen };
+}
+function capturePartitions(manager) {
+  const captured = [];
+  for (let partitionId = 0; partitionId < manager.partitionCount; partitionId++) {
+    captured.push(
+      captureComposite(manager, partitionId) ?? {
+        partitionId,
+        live: manager.serializePartition(partitionId),
+        frozen: []
+      }
+    );
+  }
+  return captured;
+}
+async function sendPartition(indexName, executors, captured) {
+  await Promise.all(
+    executors.map(
+      (workerExecutor) => workerExecutor.execute({
+        type: "deserialize",
+        indexName,
+        partitionId: captured.partitionId,
+        data: captured.live,
+        requestId: `resync-${indexName}-${captured.partitionId}`
+      })
+    )
+  );
+  if (captured.frozen.length === 0) return;
+  const segments = captured.frozen.map((shared) => ({
+    partitionId: captured.partitionId,
+    snapshot: shared.snapshot,
+    tombstonedDocIds: shared.tombstonedDocIds
+  }));
+  await Promise.all(
+    executors.map(
+      (workerExecutor) => workerExecutor.execute({
+        type: "attachSegments",
+        indexName,
+        segments,
+        requestId: `resync-attach-${indexName}-${captured.partitionId}`
+      })
+    )
+  );
+}
 async function transferIndexToPool(indexName, pool, config, manager) {
-  const allExecutors = pool.getAllExecutors();
+  await loadIndexOntoWorkers(indexName, pool.getAllExecutors(), config, manager, () => pool.addIndexToAll(indexName));
+}
+async function loadIndexOntoWorkers(indexName, executors, config, manager, onDropped) {
+  const captured = capturePartitions(manager);
   await Promise.allSettled(
-    allExecutors.map(
+    executors.map(
       (workerExecutor) => workerExecutor.execute({ type: "dropIndex", indexName, requestId: `resync-drop-${indexName}` })
     )
   );
-  pool.addIndexToAll(indexName);
+  onDropped?.();
   await Promise.all(
-    allExecutors.map(
+    executors.map(
       (workerExecutor) => workerExecutor.execute({
         type: "createIndex",
         indexName,
@@ -5245,22 +5266,25 @@ async function transferIndexToPool(indexName, pool, config, manager) {
       })
     )
   );
-  for (let i = 0; i < manager.partitionCount; i++) {
-    const serialized = manager.serializePartition(i);
-    await Promise.all(
-      allExecutors.map(
-        (workerExecutor) => workerExecutor.execute({
-          type: "deserialize",
-          indexName,
-          partitionId: i,
-          data: serialized,
-          requestId: `resync-${indexName}-${i}`
-        })
-      )
-    );
+  for (const partition of captured) {
+    await sendPartition(indexName, executors, partition);
   }
 }
 
+// src/engine/orchestration/constants.ts
+var DEFAULT_COPY_THRESHOLD = 1e3;
+var DEFAULT_COPY_IDLE_TIMEOUT_MS = 3e5;
+var COMPACTION_SEGMENT_TRIGGER = 8;
+var IDLE_MERGE_DELAY_MS = 1e3;
+var LIVE_TAIL_FREEZE_FLOOR = MIN_DOCUMENTS_FOR_SEGMENTS;
+var LIVE_TAIL_FLUSH_DOCUMENTS = 5e3;
+var MAX_PENDING_REPLICATION_DOCUMENTS = 2e4;
+var REPLICATION_WINDOW = 32;
+var LOAD_BUFFER_YIELD_INTERVAL = 1e3;
+var MAIN_COPY_LONE_QUERY_DOCUMENTS = 5e4;
+var POOL_RESTART_DELAY_MS = 1e3;
+var POOL_RESTART_DELAY_MAX_MS = 6e4;
+
 // src/engine/orchestration/eligibility.ts
 function toError3(value) {
   return value instanceof Error ? value : new Error(String(value));
@@ -5309,7 +5333,7 @@ function workerIneligibility(indexName, config, bootstrapModule) {
 function reportIneligible(state, indexName, error) {
   if (state.reportedIneligible.has(indexName)) return;
   state.reportedIneligible.add(indexName);
-  state.callbacks?.onPromotionFailure?.("index-excluded", error, false);
+  state.callbacks?.onCopyLoadFailure?.("index-excluded", error, false);
 }
 function eligibleIndexNames(state) {
   const names = [];
@@ -5323,33 +5347,26 @@ function eligibleIndexNames(state) {
   }
   return names;
 }
-function collectEligibleIndexes(state) {
-  const eligible = /* @__PURE__ */ new Map();
-  for (const name of eligibleIndexNames(state)) {
-    const manager = state.executor.getManager(name);
-    eligible.set(name, { documentCount: manager?.countDocuments() ?? 0 });
+
+// src/engine/orchestration/turn.ts
+function afterCurrentTurn(callback) {
+  if (typeof setImmediate === "function") {
+    setImmediate(callback);
+    return;
   }
-  return eligible;
+  setTimeout(callback, 0);
+}
+function yieldToEventLoop3() {
+  return new Promise((resolve) => afterCurrentTurn(resolve));
 }
 
 // src/engine/orchestration/replication.ts
-var MAX_PENDING_REPLICATION_DOCUMENTS = 2e4;
 async function dispatchToWorkers(state, action) {
   const pool = state.workerPool;
   if (!pool) return;
-  if (action.type === "createIndex") {
-    const ineligibility = workerIneligibility(action.indexName, action.config, state.bootstrapModule);
-    if (ineligibility) {
-      reportIneligible(state, action.indexName, ineligibility);
-      return;
-    }
-    pool.addIndexToAll(action.indexName);
-    state.promotedIndexes.add(action.indexName);
-  } else if ("indexName" in action && !state.promotedIndexes.has(action.indexName)) {
-    return;
-  }
-  const allExecutors = pool.getAllExecutors();
-  const results = await Promise.allSettled(allExecutors.map((workerExecutor) => workerExecutor.execute(action)));
+  const executors = "indexName" in action ? pool.executorsHolding(action.indexName) : pool.getAllExecutors();
+  if ("indexName" in action && !state.scaledOutIndexes.has(action.indexName)) return;
+  const results = await Promise.allSettled(executors.map((workerExecutor) => workerExecutor.execute(action)));
   for (const result of results) {
     if (result.status === "rejected") {
       if (action.type === "insert" && alreadyPresentOnWorker(result.reason)) {
@@ -5417,6 +5434,13 @@ function recordSegmentBroadcast(state, action) {
     }
     return;
   }
+  if (action.type === "freezeLiveTail") {
+    partitionLedger(state, action.indexName, action.partitionId).push({
+      segmentId: action.snapshot.segmentId,
+      documentCount: action.snapshot.documentCount
+    });
+    return;
+  }
   if (action.type === "swapSegments") {
     const entries = partitionLedger(state, action.indexName, action.partitionId);
     const dropped = new Set(action.dropSegmentIds);
@@ -5429,48 +5453,71 @@ function recordSegmentBroadcast(state, action) {
 function queueFor(state, indexName) {
   let queue = state.replicationQueues.get(indexName);
   if (queue === void 0) {
-    queue = { tail: Promise.resolve(), pendingActions: 0, pendingDocuments: 0 };
+    queue = { tail: Promise.resolve(), inFlight: [], pendingActions: 0, pendingDocuments: 0, drainWaiters: [] };
     state.replicationQueues.set(indexName, queue);
   }
   return queue;
 }
-function enqueue(state, indexName, action, weight) {
+function dispatchGate(queue) {
+  if (queue.inFlight.length < REPLICATION_WINDOW) return Promise.resolve();
+  return queue.inFlight[queue.inFlight.length - REPLICATION_WINDOW];
+}
+function enqueueReplication(state, indexName, action) {
+  const weight = documentWeight(action);
+  recordSegmentBroadcast(state, action);
   const queue = queueFor(state, indexName);
   queue.pendingActions += 1;
   queue.pendingDocuments += weight;
-  queue.tail = queue.tail.then(async () => {
+  const run = dispatchGate(queue).then(async () => {
     try {
       await dispatchToWorkers(state, action);
     } catch (err) {
       console.warn("Worker replication failed:", err);
     } finally {
+      const at = queue.inFlight.indexOf(run);
+      if (at !== -1) queue.inFlight.splice(at, 1);
       queue.pendingActions -= 1;
       queue.pendingDocuments -= weight;
+      if (queue.pendingDocuments < MAX_PENDING_REPLICATION_DOCUMENTS && queue.drainWaiters.length > 0) {
+        for (const resume of queue.drainWaiters.splice(0)) resume();
+      }
       if (queue.pendingActions === 0 && state.replicationQueues.get(indexName) === queue) {
         state.replicationQueues.delete(indexName);
       }
     }
   });
+  queue.inFlight.push(run);
+  queue.tail = run;
 }
 async function replicateToWorkers(state, action) {
-  if (state.promotionInProgress) {
-    state.promotionBuffer.push(detachCallerDocuments(action));
+  if (!("indexName" in action)) {
+    if (state.workerPool === null) return;
+    await awaitReplicationIdle(state);
+    await dispatchToWorkers(state, action);
     return;
   }
-  if (state.workerPool === null) return;
   const detached = detachCallerDocuments(action);
-  if (!("indexName" in detached)) {
-    await awaitReplicationIdle(state);
-    await dispatchToWorkers(state, detached);
+  const loading = state.copyLoadBuffers.get(action.indexName);
+  if (loading !== void 0) {
+    queueForCopies(state, detached);
+    if (loading.length % LOAD_BUFFER_YIELD_INTERVAL === 0) await yieldToEventLoop3();
     return;
   }
-  const weight = documentWeight(detached);
-  const queue = state.replicationQueues.get(detached.indexName);
-  if (queue !== void 0 && queue.pendingDocuments + weight > MAX_PENDING_REPLICATION_DOCUMENTS) {
-    await queue.tail;
+  const queue = state.replicationQueues.get(action.indexName);
+  if (queue !== void 0 && queue.pendingDocuments + documentWeight(detached) > MAX_PENDING_REPLICATION_DOCUMENTS) {
+    await new Promise((resume) => queue.drainWaiters.push(resume));
+  }
+  queueForCopies(state, detached);
+}
+function queueForCopies(state, action) {
+  if (!("indexName" in action)) return;
+  const loading = state.copyLoadBuffers.get(action.indexName);
+  if (loading !== void 0) {
+    loading.push(action);
+    return;
   }
-  recordSegmentBroadcast(state, detached);
-  enqueue(state, detached.indexName, detached, weight);
+  if (state.workerPool === null || !state.scaledOutIndexes.has(action.indexName)) return;
+  enqueueReplication(state, action.indexName, action);
 }
 async function awaitReplicationIdle(state, indexName) {
   if (indexName !== void 0) {
@@ -5483,63 +5530,101 @@ async function awaitReplicationIdle(state, indexName) {
     await Promise.all(tails);
   }
 }
-async function drainPromotionBuffer(state) {
-  while (state.promotionBuffer.length > 0) {
-    const action = state.promotionBuffer.shift();
-    if (action === void 0) return;
-    await dispatchToWorkers(state, action);
+
+// src/engine/orchestration/live-tail.ts
+function liveTailCount(manager, partitionId) {
+  if (partitionId >= manager.partitionCount) return 0;
+  const partition = manager.getPartition(partitionId);
+  return isCompositePartition(partition) ? partition.live.count() : partition.count();
+}
+function freezeTail(state, indexName, manager, partitionId) {
+  const segment = manager.freezeLiveTail(partitionId, (payload, documents) => {
+    const snapshot = freezeSegmentShared(payload, documents);
+    return snapshot === null ? null : createSharedFrozenSegment(snapshot);
+  });
+  if (segment === null || segment.sharedSnapshot === null) return;
+  queueForCopies(state, {
+    type: "freezeLiveTail",
+    indexName,
+    partitionId,
+    snapshot: segment.sharedSnapshot,
+    requestId: createRequestId()
+  });
+}
+function freezeLiveTail(state, indexName, manager, partitionId, floor) {
+  if (!state.scaledOutIndexes.has(indexName)) return;
+  if (liveTailCount(manager, partitionId) < floor) return;
+  try {
+    freezeTail(state, indexName, manager, partitionId);
+  } catch (err) {
+    console.warn(`Freezing the live tail of partition ${partitionId} of "${indexName}" failed:`, err);
+  }
+}
+function flushGrownTails(state, indexName) {
+  const manager = state.executor.getManager(indexName);
+  if (manager === void 0) return;
+  for (let partitionId = 0; partitionId < manager.partitionCount; partitionId++) {
+    freezeLiveTail(state, indexName, manager, partitionId, LIVE_TAIL_FLUSH_DOCUMENTS);
   }
 }
 
 // src/engine/orchestration/compaction.ts
-var COMPACTION_SEGMENT_TRIGGER = 8;
 function smallestSegmentIds(entries) {
   return [...entries].sort((a, b) => a.documentCount - b.documentCount).slice(0, COMPACTION_SEGMENT_TRIGGER).map((entry) => entry.segmentId);
 }
+function pickSegmentIds(entries, policy) {
+  if (policy === "idle") {
+    return entries.length >= 2 ? entries.map((entry) => entry.segmentId) : null;
+  }
+  return entries.length >= COMPACTION_SEGMENT_TRIGGER ? smallestSegmentIds(entries) : null;
+}
 function mainCompositeOf(manager, partitionId) {
   if (partitionId >= manager.partitionCount) return null;
   const partition = manager.getPartition(partitionId);
   return isCompositePartition(partition) ? partition : null;
 }
-function candidateSegmentIds(state, indexName, manager, partitionId) {
+function candidateSegmentIds(state, indexName, manager, partitionId, policy) {
   const composite = mainCompositeOf(manager, partitionId);
   if (composite !== null) {
     const sizes = composite.frozenSegmentSizes();
-    if (sizes.length >= COMPACTION_SEGMENT_TRIGGER) {
-      return smallestSegmentIds(
-        sizes.map((size) => ({ segmentId: size.segmentId, documentCount: size.liveDocumentCount }))
-      );
-    }
+    const picks = pickSegmentIds(
+      sizes.map((size) => ({ segmentId: size.segmentId, documentCount: size.liveDocumentCount })),
+      policy
+    );
+    if (picks !== null) return picks;
   }
   const ledger = state.segmentLedger.get(indexName)?.get(partitionId);
-  if (ledger !== void 0 && ledger.length >= COMPACTION_SEGMENT_TRIGGER) {
-    return smallestSegmentIds(ledger);
-  }
-  return null;
+  return ledger === void 0 ? null : pickSegmentIds(ledger, policy);
 }
 function mainHoldsAll(composite, segmentIds) {
   if (composite === null) return false;
   const held = new Set(composite.frozenSegmentSizes().map((size) => size.segmentId));
   return segmentIds.every((segmentId) => held.has(segmentId));
 }
-async function compactPartitionSegments2(state, indexName, manager, partitionId, segmentIds) {
-  await awaitReplicationIdle(state, indexName);
-  let snapshot = null;
+async function compactOnWorker(state, indexName, partitionId, segmentIds) {
   const pool = state.workerPool;
-  const executors = pool !== null && state.promotedIndexes.has(indexName) ? pool.getAllExecutors() : [];
-  if (executors.length > 0) {
-    try {
-      snapshot = await executors[0].execute({
-        type: "compactSegments",
-        indexName,
-        partitionId,
-        segmentIds: [...segmentIds],
-        requestId: createRequestId()
-      });
-    } catch (err) {
-      console.warn("Worker segment compaction failed, compacting on the main thread:", err);
-    }
+  if (pool === null || !state.scaledOutIndexes.has(indexName)) return null;
+  const lease = pool.leaseLeastBusy();
+  if (lease === null) return null;
+  try {
+    return await lease.executor.execute({
+      type: "compactSegments",
+      indexName,
+      partitionId,
+      segmentIds: [...segmentIds],
+      requestId: createRequestId()
+    });
+  } catch (err) {
+    console.warn("Worker segment compaction failed, compacting on the main thread:", err);
+    return null;
+  } finally {
+    lease.release();
   }
+}
+async function compactPartitionSegments2(state, indexName, manager, partitionId, segmentIds, policy) {
+  await awaitReplicationIdle(state, indexName);
+  if (policy === "idle" && !state.scaledOutIndexes.has(indexName)) return false;
+  let snapshot = await compactOnWorker(state, indexName, partitionId, segmentIds);
   const composite = mainCompositeOf(manager, partitionId);
   const holdsAll = mainHoldsAll(composite, segmentIds);
   let replacement = null;
@@ -5566,30 +5651,52 @@ async function compactPartitionSegments2(state, indexName, manager, partitionId,
   }
   return true;
 }
-async function compactIndexSegments(state, indexName) {
+async function compactIndexSegments(state, indexName, policy) {
   const manager = state.executor.getManager(indexName);
   if (!manager) return;
   const partitionIds = /* @__PURE__ */ new Set();
   for (let partitionId = 0; partitionId < manager.partitionCount; partitionId++) partitionIds.add(partitionId);
   for (const partitionId of state.segmentLedger.get(indexName)?.keys() ?? []) partitionIds.add(partitionId);
   for (const partitionId of partitionIds) {
-    let picks = candidateSegmentIds(state, indexName, manager, partitionId);
+    if (policy === "idle") {
+      await awaitReplicationIdle(state, indexName);
+      freezeLiveTail(state, indexName, manager, partitionId, LIVE_TAIL_FREEZE_FLOOR);
+    }
+    let picks = candidateSegmentIds(state, indexName, manager, partitionId, policy);
     while (picks !== null) {
-      const compacted = await compactPartitionSegments2(state, indexName, manager, partitionId, picks);
+      const compacted = await compactPartitionSegments2(state, indexName, manager, partitionId, picks, policy);
       if (!compacted) break;
-      picks = candidateSegmentIds(state, indexName, manager, partitionId);
+      picks = candidateSegmentIds(state, indexName, manager, partitionId, policy);
     }
   }
 }
-function maybeCompactSegments(state, indexName) {
-  if (state.compactionsInFlight.has(indexName)) return;
-  const run = compactIndexSegments(state, indexName).catch((err) => {
+function maybeCompactSegments(state, indexName, policy = "ingest") {
+  if (state.compactionsInFlight.has(indexName)) {
+    if (policy === "idle") scheduleIdleMerge(state, indexName);
+    return;
+  }
+  const run = compactIndexSegments(state, indexName, policy).catch((err) => {
     console.warn("Segment compaction failed:", err);
   }).finally(() => {
     state.compactionsInFlight.delete(indexName);
   });
   state.compactionsInFlight.set(indexName, run);
 }
+function scheduleIdleMerge(state, indexName) {
+  cancelIdleMerge(state, indexName);
+  const timer = setTimeout(() => {
+    state.idleMergeTimers.delete(indexName);
+    maybeCompactSegments(state, indexName, "idle");
+  }, IDLE_MERGE_DELAY_MS);
+  if (typeof timer.unref === "function") timer.unref();
+  state.idleMergeTimers.set(indexName, timer);
+}
+function cancelIdleMerge(state, indexName) {
+  const timer = state.idleMergeTimers.get(indexName);
+  if (timer === void 0) return;
+  clearTimeout(timer);
+  state.idleMergeTimers.delete(indexName);
+}
 async function awaitCompactions(state) {
   while (state.compactionsInFlight.size > 0) {
     await Promise.all([...state.compactionsInFlight.values()]);
@@ -5597,10 +5704,6 @@ async function awaitCompactions(state) {
 }
 
 // src/workers/worker-executor.ts
-var DEFAULT_BACKPRESSURE_LIMIT = 100;
-var DEFAULT_REQUEST_TIMEOUT = 3e4;
-var SHUTDOWN_TIMEOUT = 5e3;
-var CONSECUTIVE_TIMEOUTS_BEFORE_DEATH = 3;
 function errorFromEventLike(event) {
   if (event instanceof Error) {
     return event;
@@ -5618,7 +5721,7 @@ function errorFromEventLike(event) {
 }
 function createWorkerExecutor(worker, config) {
   const backpressureLimit = config?.backpressureLimit ?? DEFAULT_BACKPRESSURE_LIMIT;
-  const requestTimeout = config?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+  const requestTimeout = config?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const pending = /* @__PURE__ */ new Map();
   let deathError = null;
   let shutdownRequested = false;
@@ -5706,7 +5809,7 @@ function createWorkerExecutor(worker, config) {
       const timeoutId = setTimeout(() => {
         pending.delete(requestId);
         reject(new NarsilError(ErrorCodes.WORKER_TIMEOUT, "Shutdown timed out"));
-      }, SHUTDOWN_TIMEOUT);
+      }, SHUTDOWN_TIMEOUT_MS);
       pending.set(requestId, {
         resolve: () => resolve(),
         reject,
@@ -5742,7 +5845,9 @@ async function createWorkerFactory(entryPoint) {
   if (runtime.supportsWorkerThreads) {
     const workerThreadsModule = await import('worker_threads');
     return function nodeFactory(_workerId, onDeath) {
-      const instance = new workerThreadsModule.Worker(new URL(resolvedEntry));
+      const instance = new workerThreadsModule.Worker(new URL(resolvedEntry), {
+        resourceLimits: WORKER_RESOURCE_LIMITS
+      });
       return createWorkerExecutor(instance, { onDeath });
     };
   }
@@ -5755,136 +5860,323 @@ async function createWorkerFactory(entryPoint) {
   throw new NarsilError(ErrorCodes.WORKER_CRASHED, `No worker support available on runtime "${runtime.runtime}"`);
 }
 
-// src/engine/orchestration/promotion.ts
-async function bootstrapWorkers(state, pool, indexNames) {
-  const allExecutors = pool.getAllExecutors();
-  if (state.bootstrapModule !== void 0) {
-    const moduleUrl = state.bootstrapModule;
-    await Promise.all(
-      allExecutors.map(
-        (workerExecutor) => workerExecutor.execute({ type: "bootstrap", moduleUrl, requestId: "promote-bootstrap" })
-      )
-    );
+// src/engine/orchestration/repair.ts
+var COPY_RESTART_REASON = "A request arrived after every worker crashed and the restart delay passed";
+function nextRestartDelay(state) {
+  const delay2 = state.poolRetryDelayMs;
+  state.poolRetryDelayMs = Math.min(delay2 * 2, POOL_RESTART_DELAY_MAX_MS);
+  return delay2;
+}
+function deferPoolRestart(state) {
+  state.poolRetryAt = Date.now() + nextRestartDelay(state);
+}
+function retirePool(state, pool) {
+  if (state.workerPool !== pool) return;
+  state.workerPool = null;
+  cancelRepair(state);
+  deferPoolRestart(state);
+  for (const indexName of state.scaledOutIndexes) state.droppedCopies.set(indexName, COPY_RESTART_REASON);
+  state.scaledOutIndexes.clear();
+  state.segmentLedger.clear();
+  void pool.shutdown().catch(() => void 0);
+}
+function handleWorkerCrash(state, pool, workerId, indexNames, error) {
+  state.callbacks?.onWorkerCrash?.(workerId, indexNames, error);
+  if (pool.getAllExecutors().length === 0) {
+    retirePool(state, pool);
+    return;
   }
-  for (const name of indexNames) {
-    const entry = state.indexRegistry.get(name);
-    if (!entry) continue;
-    await Promise.all(
-      allExecutors.map(
-        (workerExecutor) => workerExecutor.execute({
-          type: "createIndex",
-          indexName: name,
-          config: entry.config,
-          requestId: `promote-create-${name}`
-        })
-      )
-    );
-    const manager = state.executor.getManager(name);
-    if (!manager) continue;
-    for (let partitionId = 0; partitionId < manager.partitionCount; partitionId++) {
-      const serialized = manager.serializePartition(partitionId);
+  scheduleRepair(state, pool);
+}
+function scheduleRepair(state, pool) {
+  if (state.workerPool !== pool || state.repairTimer !== null || state.poolRepair !== null) return;
+  const timer = setTimeout(() => {
+    state.repairTimer = null;
+    void repairPool(state, pool);
+  }, state.poolRetryDelayMs);
+  if (typeof timer.unref === "function") timer.unref();
+  state.repairTimer = timer;
+}
+function cancelRepair(state) {
+  if (state.repairTimer === null) return;
+  clearTimeout(state.repairTimer);
+  state.repairTimer = null;
+}
+async function loadOntoReplacement(state, replacement, indexName) {
+  const entry = state.indexRegistry.get(indexName);
+  const manager = state.executor.getManager(indexName);
+  if (entry === void 0 || manager === void 0 || !state.scaledOutIndexes.has(indexName)) return;
+  const buffered = [];
+  state.copyLoadBuffers.set(indexName, buffered);
+  try {
+    await loadIndexOntoWorkers(indexName, [replacement.executor], entry.config, manager);
+    replacement.hold(indexName);
+  } finally {
+    state.copyLoadBuffers.delete(indexName);
+    for (const action of buffered) enqueueReplication(state, indexName, action);
+  }
+}
+async function replaceWorker(state, pool, workerId) {
+  const replacement = pool.spawnReplacement(workerId);
+  if (replacement === null) return;
+  try {
+    if (state.bootstrapModule !== void 0) {
+      await replacement.executor.execute({
+        type: "bootstrap",
+        moduleUrl: state.bootstrapModule,
+        requestId: createRequestId()
+      });
+    }
+    for (const indexName of [...state.scaledOutIndexes]) {
+      await loadOntoReplacement(state, replacement, indexName);
+    }
+    replacement.admit();
+  } catch (err) {
+    replacement.abandon();
+    throw err;
+  }
+}
+async function replaceDeadWorkers(state, pool) {
+  for (const workerId of pool.deadWorkerIds()) {
+    if (state.workerPool !== pool) return;
+    await replaceWorker(state, pool, workerId);
+  }
+  state.poolRetryDelayMs = POOL_RESTART_DELAY_MS;
+}
+function repairPool(state, pool) {
+  if (state.workerPool !== pool) return Promise.resolve();
+  if (state.poolRepair !== null) return state.poolRepair;
+  const run = replaceDeadWorkers(state, pool).catch((err) => {
+    nextRestartDelay(state);
+    console.warn("Replacing a crashed worker failed:", err);
+  }).finally(() => {
+    state.poolRepair = null;
+    if (pool.deadWorkerIds().length > 0) scheduleRepair(state, pool);
+  });
+  state.poolRepair = run;
+  return run;
+}
+
+// src/engine/orchestration/scale-out.ts
+var COPY_RELOAD_REASON = "A request arrived after an idle spell dropped the worker copies";
+function copiesAllowed(state) {
+  if (!state.workersEnabled || state.scaleOutBlocked) return false;
+  return state.workerPool !== null || Date.now() >= state.poolRetryAt;
+}
+async function startPool(state) {
+  eligibleIndexNames(state);
+  const factory = await createWorkerFactory();
+  let started = null;
+  const pool = createWorkerPool({
+    count: state.keywordWorkerCount,
+    workerFactory: factory,
+    onWorkerCrash(workerId, indexNames, error) {
+      if (started !== null) handleWorkerCrash(state, started, workerId, indexNames, error);
+    }
+  });
+  started = pool;
+  try {
+    pool.spawnAll();
+    if (state.bootstrapModule !== void 0) {
+      const moduleUrl = state.bootstrapModule;
       await Promise.all(
-        allExecutors.map(
-          (workerExecutor) => workerExecutor.execute({
-            type: "deserialize",
-            indexName: name,
-            partitionId,
-            data: serialized,
-            requestId: `promote-sync-${name}-${partitionId}`
-          })
+        pool.getAllExecutors().map(
+          (workerExecutor) => workerExecutor.execute({ type: "bootstrap", moduleUrl, requestId: "copies-bootstrap" })
         )
       );
     }
+  } catch (err) {
+    await pool.shutdown().catch(() => void 0);
+    throw err;
   }
+  return pool;
 }
-async function runPromotion(state, reason) {
-  try {
-    const promotable = eligibleIndexNames(state);
-    if (promotable.length === 0) {
-      state.promotionBuffer.length = 0;
-      return;
-    }
-    const factory = await createWorkerFactory();
-    const pool = createWorkerPool({
-      count: state.config?.workers?.count,
-      workerFactory: factory,
-      onWorkerCrash(workerId, indexNames, error) {
-        state.callbacks?.onWorkerCrash?.(workerId, indexNames, error);
+async function ensurePool(state) {
+  if (state.workerPool !== null) return state.workerPool;
+  if (state.poolStart === null) {
+    state.poolStart = startPool(state).then(
+      (pool) => {
+        state.workerPool = pool;
+        state.poolStart = null;
+        return pool;
+      },
+      (err) => {
+        state.poolStart = null;
+        deferPoolRestart(state);
+        throw err;
       }
-    });
-    for (const name of promotable) {
-      pool.addIndexToAll(name);
-    }
-    await bootstrapWorkers(state, pool, promotable);
-    state.workerPool = pool;
-    for (const name of promotable) {
-      state.promotedIndexes.add(name);
-      state.awaitingBufferedWrites.add(name);
-    }
-    state.promoter.markPromoted();
-    await drainPromotionBuffer(state);
-    state.awaitingBufferedWrites.clear();
-    state.callbacks?.onPromotion?.(pool.workerCount, reason);
+    );
+  }
+  return state.poolStart;
+}
+function documentCountOf(state, indexName) {
+  return state.executor.getManager(indexName)?.countDocuments() ?? 0;
+}
+function copyThresholdReason(state, indexName) {
+  return `Index "${indexName}" holds ${documentCountOf(state, indexName)} documents, reaching the copy threshold of ${state.copyThreshold}`;
+}
+function indexReadyForCopies(state, indexName, incomingCount = 0) {
+  if (!copiesAllowed(state)) return false;
+  if (state.scaledOutIndexes.has(indexName) || state.desyncedIndexes.has(indexName)) return false;
+  if (state.copyTransitions.has(indexName)) return false;
+  if (state.callbacks?.shouldDeferCopies?.()) return false;
+  const entry = state.indexRegistry.get(indexName);
+  if (entry === void 0 || state.executor.getManager(indexName) === void 0) return false;
+  if (documentCountOf(state, indexName) + incomingCount < state.copyThreshold) return false;
+  const ineligibility = workerIneligibility(indexName, entry.config, state.bootstrapModule);
+  if (ineligibility !== null) {
+    reportIneligible(state, indexName, ineligibility);
+    return false;
+  }
+  return true;
+}
+async function loadCopies(state, indexName, reason) {
+  const entry = state.indexRegistry.get(indexName);
+  const manager = state.executor.getManager(indexName);
+  if (entry === void 0 || manager === void 0) return;
+  const ineligibility = workerIneligibility(indexName, entry.config, state.bootstrapModule);
+  if (ineligibility !== null) {
+    reportIneligible(state, indexName, ineligibility);
+    return;
+  }
+  const pool = await ensurePool(state);
+  if (state.executor.getManager(indexName) === void 0) return;
+  const dropReason = state.droppedCopies.get(indexName);
+  const reload = state.droppedCopies.delete(indexName);
+  const buffered = [];
+  state.copyLoadBuffers.set(indexName, buffered);
+  try {
+    await transferIndexToPool(indexName, pool, entry.config, manager);
+    state.scaledOutIndexes.add(indexName);
+    state.lastAccessAt.set(indexName, Date.now());
+    state.poolRetryDelayMs = POOL_RESTART_DELAY_MS;
+    for (const action of buffered) enqueueReplication(state, indexName, action);
   } catch (err) {
-    state.promotionBuffer.length = 0;
+    if (dropReason !== void 0) state.droppedCopies.set(indexName, dropReason);
     throw err;
   } finally {
-    state.awaitingBufferedWrites.clear();
-    state.promotionInProgress = false;
+    state.copyLoadBuffers.delete(indexName);
+  }
+  if (reload) state.copyReloadCounts.set(indexName, (state.copyReloadCounts.get(indexName) ?? 0) + 1);
+  scheduleIdleMerge(state, indexName);
+  state.callbacks?.onCopiesLoaded?.(pool.workerCount, reason);
+}
+async function loadAfter(previous, state, indexName, reason) {
+  if (previous !== void 0) await previous.done;
+  if (state.poolRepair !== null) await state.poolRepair;
+  if (!copiesAllowed(state)) return;
+  if (state.scaledOutIndexes.has(indexName) || state.desyncedIndexes.has(indexName)) return;
+  await loadCopies(state, indexName, reason);
+}
+function scaleOutIndex(state, indexName, reason) {
+  const previous = state.copyTransitions.get(indexName);
+  if (previous !== void 0 && previous.kind !== "drop") return previous.done;
+  const kind = state.droppedCopies.has(indexName) ? "reload" : "load";
+  const done = loadAfter(previous, state, indexName, reason).catch((err) => {
+    const error = toError3(err);
+    state.scaleOutBlocked = isDeterministicFailure(error);
+    state.callbacks?.onCopyLoadFailure?.(reason, error, !state.scaleOutBlocked);
+  }).finally(() => {
+    if (state.copyTransitions.get(indexName)?.done === done) state.copyTransitions.delete(indexName);
+  });
+  state.copyTransitions.set(indexName, { kind, done });
+  return done;
+}
+async function scaleOutReadyIndexes(state) {
+  if (!copiesAllowed(state)) return;
+  for (const indexName of state.indexRegistry.keys()) {
+    if (!indexReadyForCopies(state, indexName)) continue;
+    const reason = copyThresholdReason(state, indexName);
+    setTimeout(() => {
+      void scaleOutIndex(state, indexName, reason);
+    }, 0);
+  }
+}
+async function scaleOutBeforeBatch(state, indexName, incomingCount) {
+  if (incomingCount <= 0) return;
+  const pending = state.copyTransitions.get(indexName);
+  if (pending !== void 0) {
+    if (pending.kind === "load") await pending.done;
+    return;
   }
+  if (!indexReadyForCopies(state, indexName, incomingCount)) return;
+  await scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
 }
-async function promoteBeforeBatch(state, indexName, incomingCount) {
-  if (!state.workersEnabled || state.promotionBlocked || state.workerPool || incomingCount <= 0) return;
-  if (state.promotionInProgress) {
-    if (state.promotionRun) await state.promotionRun;
+
+// src/engine/orchestration/idle.ts
+function isIndexBusy(state, indexName) {
+  return state.poolRepair !== null || state.copyTransitions.has(indexName) || state.replicationQueues.has(indexName) || state.compactionsInFlight.has(indexName);
+}
+function noteAccess(state, indexName) {
+  state.lastAccessAt.set(indexName, Date.now());
+  if (!copiesAllowed(state)) return;
+  const reloadReason = state.droppedCopies.get(indexName);
+  if (reloadReason !== void 0) {
+    const transition = state.copyTransitions.get(indexName);
+    if (transition !== void 0 && transition.kind !== "drop") return;
+    void scaleOutIndex(state, indexName, reloadReason);
     return;
   }
-  if (state.callbacks?.shouldDeferPromotion?.()) return;
-  const indexMap = collectEligibleIndexes(state);
-  const anticipated = indexMap.get(indexName);
-  if (anticipated === void 0) return;
-  anticipated.documentCount += incomingCount;
-  const result = state.promoter.check(indexMap);
-  if (!result.shouldPromote) return;
-  state.promotionInProgress = true;
-  const run = runPromotion(state, result.reason).catch((err) => {
-    const error = toError3(err);
-    state.promotionBlocked = isDeterministicFailure(error);
-    state.promotionInProgress = false;
-    state.callbacks?.onPromotionFailure?.(result.reason, error, !state.promotionBlocked);
-  });
-  const tracked = run.then(() => {
-    state.promotionRun = null;
+  if (indexReadyForCopies(state, indexName)) {
+    void scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
+  }
+}
+async function releaseCopies(state, indexName) {
+  const pool = state.workerPool;
+  if (pool === null) return;
+  await awaitReplicationIdle(state, indexName);
+  const cutoff = Date.now() - state.copyIdleTimeoutMs;
+  if ((state.lastAccessAt.get(indexName) ?? Date.now()) > cutoff) return;
+  if (!state.scaledOutIndexes.has(indexName) || state.compactionsInFlight.has(indexName)) return;
+  state.scaledOutIndexes.delete(indexName);
+  state.droppedCopies.set(indexName, COPY_RELOAD_REASON);
+  cancelIdleMerge(state, indexName);
+  const outcomes = await Promise.allSettled(
+    pool.executorsHolding(indexName).map((worker) => worker.execute({ type: "dropIndex", indexName, requestId: `idle-drop-${indexName}` }))
+  );
+  for (const outcome of outcomes) {
+    if (outcome.status === "rejected") console.warn("Dropping an idle worker copy failed:", outcome.reason);
+  }
+  pool.removeIndex(indexName);
+  state.segmentLedger.delete(indexName);
+}
+async function dropIdleCopies(state, indexName) {
+  const previous = state.copyTransitions.get(indexName);
+  if (previous !== void 0) return;
+  const done = releaseCopies(state, indexName).catch((err) => {
+    console.warn("Dropping idle worker copies failed:", err);
+  }).finally(() => {
+    if (state.copyTransitions.get(indexName)?.done === done) state.copyTransitions.delete(indexName);
   });
-  state.promotionRun = tracked;
-  await tracked;
-}
-async function checkPromotion(state) {
-  if (!state.workersEnabled || state.promotionInProgress || state.promotionBlocked || state.workerPool) return;
-  if (state.callbacks?.shouldDeferPromotion?.()) return;
-  const indexMap = collectEligibleIndexes(state);
-  if (indexMap.size === 0) return;
-  const result = state.promoter.check(indexMap);
-  if (!result.shouldPromote) return;
-  state.promotionInProgress = true;
-  setTimeout(() => {
-    const run = runPromotion(state, result.reason).catch((err) => {
-      const error = toError3(err);
-      state.promotionBlocked = isDeterministicFailure(error);
-      state.promotionInProgress = false;
-      state.callbacks?.onPromotionFailure?.(result.reason, error, !state.promotionBlocked);
-    });
-    state.promotionRun = run.then(() => {
-      state.promotionRun = null;
-    });
-  }, 0);
+  state.copyTransitions.set(indexName, { kind: "drop", done });
+  await done;
+}
+async function sweepIdleCopies(state) {
+  const cutoff = Date.now() - state.copyIdleTimeoutMs;
+  for (const indexName of [...state.scaledOutIndexes]) {
+    if ((state.lastAccessAt.get(indexName) ?? Date.now()) > cutoff) continue;
+    if (isIndexBusy(state, indexName)) continue;
+    await dropIdleCopies(state, indexName);
+  }
+}
+function startIdleSweep(state) {
+  if (!state.workersEnabled || state.idleSweep !== null) return;
+  const interval = Math.min(MAX_SWEEP_INTERVAL_MS, Math.max(MIN_SWEEP_INTERVAL_MS, state.copyIdleTimeoutMs / 2));
+  const timer = setInterval(() => void sweepIdleCopies(state).catch(() => void 0), interval);
+  if (typeof timer.unref === "function") timer.unref();
+  state.idleSweep = timer;
+}
+function stopIdleSweep(state) {
+  if (state.idleSweep === null) return;
+  clearInterval(state.idleSweep);
+  state.idleSweep = null;
 }
 
 // src/engine/orchestration/search.ts
-function partitionsPerWorker(totalPartitions, workerCount) {
-  const assignments = Array.from({ length: workerCount }, () => []);
-  for (let partitionId = 0; partitionId < totalPartitions; partitionId++) {
-    assignments[partitionId % workerCount].push(partitionId);
+function partitionsPerLease(scope, leaseCount) {
+  const assignments = Array.from({ length: leaseCount }, () => []);
+  for (let at = 0; at < scope.length; at++) {
+    assignments[at % leaseCount].push(scope[at]);
   }
   return assignments;
 }
@@ -5902,67 +6194,76 @@ function mergeWorkerResults(results) {
     facets: workerFacets.length > 0 ? mergeFacets(workerFacets) : void 0
   };
 }
+function scoresPerPartition(state, indexName, params, globalStats) {
+  const mode = params.scoring ?? state.indexRegistry.get(indexName)?.config.defaultScoring ?? "local";
+  if (mode === "local") return true;
+  return mode === "broadcast" && globalStats !== void 0;
+}
+function queryAction(indexName, params, globalStats, partitionIds) {
+  return {
+    type: "query",
+    indexName,
+    params,
+    requestId: createRequestId(),
+    ...partitionIds !== void 0 ? { partitionIds } : {},
+    ...globalStats !== void 0 ? { globalStats } : {}
+  };
+}
+async function runSplit(leases, scope, indexName, params, globalStats) {
+  const assignments = partitionsPerLease(scope, leases.length);
+  const results = await Promise.all(
+    assignments.map(
+      (partitionIds, at) => leases[at].executor.execute(queryAction(indexName, params, globalStats, partitionIds)).finally(() => leases[at].release())
+    )
+  );
+  return mergeWorkerResults(results);
+}
+function takeMainCopyTurn(state) {
+  if (state.mainCopyTurnTaken) return false;
+  state.mainCopyTurnTaken = true;
+  afterCurrentTurn(() => {
+    state.mainCopyTurnTaken = false;
+  });
+  return true;
+}
+function answersFasterOnMainCopy(state, pool, manager) {
+  if (pool.queriesInFlight() > 0) return false;
+  if (manager.countDocuments() > MAIN_COPY_LONE_QUERY_DOCUMENTS) return false;
+  return takeMainCopyTurn(state);
+}
 async function searchViaWorker(state, indexName, params, globalStats, partitionIds) {
   const pool = state.workerPool;
   if (!pool) return null;
-  if (!state.promotedIndexes.has(indexName)) return null;
-  if (state.awaitingBufferedWrites.has(indexName)) return null;
+  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;
-  const allExecutors = pool.getAllExecutors();
-  if (allExecutors.length === 0) return null;
-  const stats = globalStats !== void 0 ? { globalStats } : {};
-  if (allExecutors.length === 1) {
-    try {
-      return await allExecutors[0].execute({
-        type: "query",
-        indexName,
-        params,
-        requestId: createRequestId(),
-        ...partitionIds !== void 0 ? { partitionIds } : {},
-        ...stats
-      });
-    } catch (err) {
-      console.warn("Worker search failed, falling back to local:", err);
-      return null;
-    }
-  }
-  const assignments = partitionsPerWorker(manager.partitionCount, allExecutors.length);
-  const scopedAssignments = partitionIds === void 0 ? assignments : assignments.map((assigned) => assigned.filter((partitionId) => partitionIds.includes(partitionId)));
-  const activeAssignments = [];
-  for (let index = 0; index < allExecutors.length; index++) {
-    if (scopedAssignments[index].length > 0) {
-      activeAssignments.push({ executor: allExecutors[index], partitionIds: scopedAssignments[index] });
-    }
-  }
-  if (activeAssignments.length === 0) {
-    return { scored: [], totalMatched: 0 };
-  }
+  if (answersFasterOnMainCopy(state, pool, manager)) return null;
+  const scope = partitionIds ?? Array.from({ length: manager.partitionCount }, (_, partitionId) => partitionId);
+  const idle = pool.leaseIdle(scope.length);
+  const leases = [];
   try {
-    const results = await Promise.all(
-      activeAssignments.map(
-        (assignment) => assignment.executor.execute({
-          type: "query",
-          indexName,
-          params,
-          requestId: createRequestId(),
-          partitionIds: assignment.partitionIds,
-          ...stats
-        })
-      )
-    );
-    return mergeWorkerResults(results);
+    if (idle.length >= 2 && scoresPerPartition(state, indexName, params, globalStats)) {
+      leases.push(...idle);
+      return await runSplit(leases, scope, indexName, params, globalStats);
+    }
+    for (const lease2 of idle.slice(1)) lease2.release();
+    const lease = idle[0] ?? (takeMainCopyTurn(state) ? null : pool.leaseLeastBusy());
+    if (lease === null) return null;
+    leases.push(lease);
+    return await lease.executor.execute(queryAction(indexName, params, globalStats, partitionIds));
   } catch (err) {
-    console.warn("Parallel worker search failed, falling back to local:", err);
+    console.warn("Worker search failed, falling back to local:", err);
     return null;
+  } finally {
+    for (const lease of leases) lease.release();
   }
 }
 
 // src/engine/orchestration/segments.ts
 function segmentBuildConcurrency(state, indexName) {
-  if (!state.promotedIndexes.has(indexName)) return 0;
+  if (!state.scaledOutIndexes.has(indexName)) return 0;
   return state.workerPool?.workerCount ?? 0;
 }
 async function buildSegments(state, requests) {
@@ -5979,44 +6280,55 @@ async function buildSegments(state, requests) {
 }
 
 // src/engine/orchestration/index.ts
-function createWorkerOrchestrator(config, executor, promoter, indexRegistry, callbacks) {
+function workersEnabledByDefault() {
+  return detectRuntime().runtime !== "browser";
+}
+function copyIdleTimeoutBeforeClose(closeAfterMs) {
+  return closeAfterMs === void 0 ? DEFAULT_COPY_IDLE_TIMEOUT_MS : Math.min(DEFAULT_COPY_IDLE_TIMEOUT_MS, closeAfterMs);
+}
+function createWorkerOrchestrator(config, executor, indexRegistry, callbacks) {
   const state = {
     config,
     executor,
-    promoter,
     indexRegistry,
     callbacks,
-    workersEnabled: config?.workers?.enabled === true,
+    workersEnabled: config?.workers?.enabled ?? workersEnabledByDefault(),
+    keywordWorkerCount: splitWorkerBudget(resolveWorkerCount(config?.workers?.count)).keyword,
+    copyThreshold: config?.workers?.promotionThreshold ?? DEFAULT_COPY_THRESHOLD,
+    copyIdleTimeoutMs: config?.workers?.idleTimeoutMs ?? copyIdleTimeoutBeforeClose(config?.lifecycle?.idleTimeoutMs),
     bootstrapModule: config?.workers?.bootstrapModule,
-    promotionBuffer: [],
-    awaitingBufferedWrites: /* @__PURE__ */ new Set(),
     reportedIneligible: /* @__PURE__ */ new Set(),
-    promotedIndexes: /* @__PURE__ */ new Set(),
+    scaledOutIndexes: /* @__PURE__ */ new Set(),
+    desyncedIndexes: /* @__PURE__ */ new Set(),
+    copyLoadBuffers: /* @__PURE__ */ new Map(),
+    copyTransitions: /* @__PURE__ */ new Map(),
+    droppedCopies: /* @__PURE__ */ new Map(),
+    lastAccessAt: /* @__PURE__ */ new Map(),
+    copyReloadCounts: /* @__PURE__ */ new Map(),
     replicationQueues: /* @__PURE__ */ new Map(),
     segmentLedger: /* @__PURE__ */ new Map(),
     compactionsInFlight: /* @__PURE__ */ new Map(),
+    idleMergeTimers: /* @__PURE__ */ new Map(),
     workerPool: null,
-    promotionInProgress: false,
-    promotionBlocked: false,
-    promotionRun: null
+    poolStart: null,
+    poolRetryAt: 0,
+    poolRetryDelayMs: POOL_RESTART_DELAY_MS,
+    poolRepair: null,
+    mainCopyTurnTaken: false,
+    repairTimer: null,
+    scaleOutBlocked: false,
+    idleSweep: null
   };
-  async function resyncIndex(indexName, wasPromoted) {
-    if (state.promotionRun) {
-      await state.promotionRun.catch(() => void 0);
-    }
-    const pool = state.workerPool;
-    if (!pool) return;
-    if (!wasPromoted && !state.promotedIndexes.has(indexName)) return;
-    const entry = indexRegistry.get(indexName);
-    if (!entry) return;
-    if (workerIneligibility(indexName, entry.config, state.bootstrapModule)) return;
-    const manager = executor.getManager(indexName);
-    if (!manager) return;
-    state.promotedIndexes.delete(indexName);
-    await awaitReplicationIdle(state, indexName);
-    state.segmentLedger.delete(indexName);
-    await transferIndexToPool(indexName, pool, entry.config, manager);
-    state.promotedIndexes.add(indexName);
+  startIdleSweep(state);
+  async function resyncIndex(indexName, wasScaledOut) {
+    state.desyncedIndexes.delete(indexName);
+    if (!wasScaledOut) return;
+    await scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
+  }
+  async function openIndex(indexName) {
+    state.droppedCopies.delete(indexName);
+    if (!indexReadyForCopies(state, indexName)) return;
+    await scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
   }
   async function getWorkerMemoryStats() {
     if (!state.workerPool) return [];
@@ -6028,93 +6340,222 @@ function createWorkerOrchestrator(config, executor, promoter, indexRegistry, cal
       external: report.external
     }));
   }
+  function workerCopies() {
+    const reports = [];
+    for (const indexName of indexRegistry.keys()) {
+      reports.push({
+        indexName,
+        scaledOut: state.scaledOutIndexes.has(indexName),
+        reloadCount: state.copyReloadCounts.get(indexName) ?? 0
+      });
+    }
+    return reports;
+  }
   async function shutdown() {
+    stopIdleSweep(state);
+    cancelRepair(state);
+    for (const indexName of [...state.idleMergeTimers.keys()]) cancelIdleMerge(state, indexName);
+    await Promise.allSettled([...state.copyTransitions.values()].map((transition) => transition.done));
+    if (state.poolRepair !== null) await state.poolRepair;
+    if (state.poolStart !== null) await state.poolStart.catch(() => void 0);
     if (state.workerPool) {
       await awaitCompactions(state);
       await awaitReplicationIdle(state);
       await state.workerPool.shutdown();
       state.workerPool = null;
-      state.promotedIndexes.clear();
+      state.scaledOutIndexes.clear();
       state.replicationQueues.clear();
       state.segmentLedger.clear();
     }
   }
-  async function awaitPromotionIdle() {
-    while (state.promotionInProgress) {
-      const run = state.promotionRun;
-      if (run !== null) {
-        await run;
-      } else {
-        await new Promise((resolve) => setTimeout(resolve, 0));
+  async function restoreAfterFailedClose(indexName, failure) {
+    const pool = state.workerPool;
+    const entry = indexRegistry.get(indexName);
+    const manager = executor.getManager(indexName);
+    if (pool !== null && entry !== void 0 && manager !== void 0) {
+      try {
+        await transferIndexToPool(indexName, pool, entry.config, manager);
+        state.scaledOutIndexes.add(indexName);
+      } catch (repairError) {
+        throw new NarsilError(
+          ErrorCodes.WORKER_CRASHED,
+          `Worker copies for index "${indexName}" could not be restored after close failed`,
+          {
+            indexName,
+            closeError: failure.reason instanceof Error ? failure.reason.message : String(failure.reason),
+            repairError: repairError instanceof Error ? repairError.message : String(repairError)
+          }
+        );
       }
     }
+    if (failure.reason instanceof NarsilError) throw failure.reason;
+    throw new NarsilError(ErrorCodes.WORKER_CRASHED, `A worker could not close index "${indexName}"`, {
+      indexName,
+      cause: failure.reason instanceof Error ? failure.reason.message : String(failure.reason)
+    });
   }
   async function closeIndex(indexName) {
-    await awaitPromotionIdle();
+    if (state.poolRepair !== null) await state.poolRepair;
+    const transition = state.copyTransitions.get(indexName);
+    if (transition !== void 0) await transition.done;
     await awaitReplicationIdle(state, indexName);
     await awaitCompactions(state);
+    cancelIdleMerge(state, indexName);
     const pool = state.workerPool;
-    if (pool !== null && state.promotedIndexes.has(indexName)) {
+    if (pool !== null && state.scaledOutIndexes.has(indexName)) {
+      state.scaledOutIndexes.delete(indexName);
       const outcomes = await Promise.allSettled(
-        pool.getAllExecutors().map((worker) => worker.execute({ type: "dropIndex", indexName, requestId: `close-${indexName}` }))
+        pool.executorsHolding(indexName).map((worker) => worker.execute({ type: "dropIndex", indexName, requestId: `close-${indexName}` }))
       );
       const failure = outcomes.find((outcome) => outcome.status === "rejected");
-      if (failure?.status === "rejected") {
-        const entry = indexRegistry.get(indexName);
-        const manager = executor.getManager(indexName);
-        if (entry !== void 0 && manager !== void 0) {
-          try {
-            await transferIndexToPool(indexName, pool, entry.config, manager);
-          } catch (repairError) {
-            throw new NarsilError(
-              ErrorCodes.WORKER_CRASHED,
-              `Worker copies for index "${indexName}" could not be restored after close failed`,
-              {
-                indexName,
-                closeError: failure.reason instanceof Error ? failure.reason.message : String(failure.reason),
-                repairError: repairError instanceof Error ? repairError.message : String(repairError)
-              }
-            );
-          }
-        }
-        if (failure.reason instanceof NarsilError) throw failure.reason;
-        throw new NarsilError(ErrorCodes.WORKER_CRASHED, `A worker could not close index "${indexName}"`, {
-          indexName,
-          cause: failure.reason instanceof Error ? failure.reason.message : String(failure.reason)
-        });
-      }
+      if (failure?.status === "rejected") await restoreAfterFailedClose(indexName, failure);
       pool.removeIndex(indexName);
     }
-    state.promotedIndexes.delete(indexName);
+    state.droppedCopies.delete(indexName);
+    state.desyncedIndexes.delete(indexName);
+    state.lastAccessAt.delete(indexName);
     state.replicationQueues.delete(indexName);
     state.segmentLedger.delete(indexName);
   }
   async function replicate(action) {
     await replicateToWorkers(state, action);
-    if (action.type === "attachSegments") {
-      maybeCompactSegments(state, action.indexName);
+    if (!("indexName" in action)) return;
+    if (action.type === "attachSegments") maybeCompactSegments(state, action.indexName);
+    if (action.type === "insert" || action.type === "update") flushGrownTails(state, action.indexName);
+    if (state.scaledOutIndexes.has(action.indexName) || state.copyLoadBuffers.has(action.indexName)) {
+      scheduleIdleMerge(state, action.indexName);
     }
   }
   return {
-    checkPromotion: () => checkPromotion(state),
-    promoteBeforeBatch: (indexName, incomingCount) => promoteBeforeBatch(state, indexName, incomingCount),
+    scaleOutReadyIndexes: () => scaleOutReadyIndexes(state),
+    scaleOutBeforeBatch: (indexName, incomingCount) => scaleOutBeforeBatch(state, indexName, incomingCount),
     replicateToWorkers: replicate,
     awaitReplication: (indexName) => awaitReplicationIdle(state, indexName),
     awaitCompactions: () => awaitCompactions(state),
-    openIndex: (indexName) => resyncIndex(indexName, true),
+    openIndex,
     closeIndex,
-    isIndexBusy: (indexName) => state.promotionInProgress || state.replicationQueues.has(indexName) || state.compactionsInFlight.has(indexName),
+    isIndexBusy: (indexName) => isIndexBusy(state, indexName),
     buildSegments: (requests) => buildSegments(state, requests),
     segmentBuildConcurrency: (indexName) => segmentBuildConcurrency(state, indexName),
     searchViaWorker: (indexName, params, globalStats, partitionIds) => searchViaWorker(state, indexName, params, globalStats, partitionIds),
-    isPromoted: () => state.workerPool !== null,
-    desyncIndex: (indexName) => state.promotedIndexes.delete(indexName),
+    hasWorkerPool: () => state.workerPool !== null,
+    desyncIndex: (indexName) => {
+      state.desyncedIndexes.add(indexName);
+      return state.scaledOutIndexes.delete(indexName);
+    },
     resyncIndex,
+    noteAccess: (indexName) => noteAccess(state, indexName),
+    workerCopies,
     getWorkerMemoryStats,
     shutdown
   };
 }
 
+// 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());
@@ -6156,10 +6597,13 @@ function createWatermarkNotifier(deps) {
 
 // src/engine/core.ts
 function createEngineCore(config, hooks) {
-  const executor = createDirectExecutor();
-  const promoter = createExecutionPromoter({
-    perIndexThreshold: config?.workers?.promotionThreshold,
-    totalThreshold: config?.workers?.totalPromotionThreshold
+  validateWorkerConfig(config?.workers, config?.lifecycle);
+  const vectorWorkerCount = splitWorkerBudget(resolveWorkerCount(config?.workers?.count)).vector;
+  const executor = createDirectExecutor({
+    vectorWorkerCopies: {
+      enabled: (config?.workers?.enabled ?? workersEnabledByDefault()) && vectorWorkerCount > 0,
+      count: vectorWorkerCount
+    }
   });
   const pluginRegistry = createPluginRegistry();
   if (config?.plugins) {
@@ -6178,11 +6622,11 @@ function createEngineCore(config, hooks) {
   const shutdownState = { isShutdown: false };
   const abortController = new AbortController();
   const rebalancingIndexes = /* @__PURE__ */ new Set();
-  const orchestrator = createWorkerOrchestrator(config, executor, promoter, indexRegistry, {
-    shouldDeferPromotion() {
+  const orchestrator = createWorkerOrchestrator(config, executor, indexRegistry, {
+    shouldDeferCopies() {
       return rebalancingIndexes.size > 0;
     },
-    onPromotion(workerCount, reason) {
+    onCopiesLoaded(workerCount, reason) {
       const handlers = eventHandlers.get("workerPromote");
       if (handlers) {
         for (const handler of handlers) handler({ workerCount, reason });
@@ -6191,10 +6635,10 @@ function createEngineCore(config, hooks) {
         console.warn("onWorkerPromote plugin hook failed:", err instanceof Error ? err.message : String(err));
       });
     },
-    onPromotionFailure(reason, error, retryable) {
+    onCopyLoadFailure(reason, error, retryable) {
       const handlers = eventHandlers.get("workerPromoteFailure");
       if (!handlers || handlers.size === 0) {
-        console.warn(`Worker promotion failed (${reason}):`, error);
+        console.warn(`Loading worker copies failed (${reason}):`, error);
         return;
       }
       for (const handler of handlers) handler({ reason, error, retryable });
@@ -6383,7 +6827,8 @@ function createEngineCore(config, hooks) {
     rebalancingIndexes,
     requireManager,
     onClose: hooks?.onIndexClose,
-    onOpen: hooks?.onIndexOpen
+    onOpen: hooks?.onIndexOpen,
+    onAccess: (indexName) => orchestrator.noteAccess(indexName)
   });
   const mutationCtx = {
     executor,
@@ -6417,7 +6862,6 @@ function createEngineCore(config, hooks) {
   };
   return {
     executor,
-    promoter,
     pluginRegistry,
     durability,
     invalidation,
@@ -6444,96 +6888,6 @@ function createEngineCore(config, hooks) {
   };
 }
 
-// src/engine/validation.ts
-var INDEX_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-var MAX_DOC_ID_LENGTH = 512;
-var BATCH_CHUNK_SIZE = 1e3;
-var DEFAULT_LIMIT = DEFAULT_PAGE_SIZE;
-var DEFAULT_OFFSET = 0;
-function now() {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return performance.now();
-  }
-  return Date.now();
-}
-function validateIndexName(name) {
-  if (!name || name.length === 0) {
-    throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, "Index name must not be empty", { indexName: name });
-  }
-  if (name.length > MAX_INDEX_NAME_LENGTH) {
-    throw new NarsilError(
-      ErrorCodes.INDEX_NOT_FOUND,
-      `Index name must not exceed ${MAX_INDEX_NAME_LENGTH} characters`,
-      {
-        indexName: name,
-        length: name.length
-      }
-    );
-  }
-  if (!INDEX_NAME_PATTERN.test(name)) {
-    throw new NarsilError(
-      ErrorCodes.INDEX_NOT_FOUND,
-      `Index name "${name}" contains invalid characters; use alphanumeric, dots, hyphens, and underscores only`,
-      { indexName: name }
-    );
-  }
-  if (name.includes("..")) {
-    throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Index name "${name}" must not contain ".."`, { indexName: name });
-  }
-}
-function validateDocId(docId) {
-  if (!docId || docId.length === 0) {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Document ID must not be empty", { docId });
-  }
-  if (docId.length > MAX_DOC_ID_LENGTH) {
-    throw new NarsilError(
-      ErrorCodes.DOC_VALIDATION_FAILED,
-      `Document ID must not exceed ${MAX_DOC_ID_LENGTH} characters`,
-      {
-        docId,
-        length: docId.length
-      }
-    );
-  }
-  if (docId.includes("\0")) {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Document ID must not contain null bytes", { docId });
-  }
-}
-function validatePartitionConfig(partitions) {
-  const { maxDocsPerPartition, maxPartitions, watermark } = partitions;
-  if (maxDocsPerPartition !== void 0 && (!Number.isInteger(maxDocsPerPartition) || maxDocsPerPartition < 1)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "partitions.maxDocsPerPartition must be a positive integer", {
-      maxDocsPerPartition
-    });
-  }
-  if (maxPartitions !== void 0 && (!Number.isInteger(maxPartitions) || maxPartitions < 1)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "partitions.maxPartitions must be a positive integer", {
-      maxPartitions
-    });
-  }
-  if (watermark !== void 0 && (typeof watermark !== "number" || !(watermark > 0) || watermark > 1)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "partitions.watermark must be above 0 and at most 1", {
-      watermark
-    });
-  }
-}
-function validateBM25Params(bm25) {
-  if (bm25 === void 0) return;
-  const { k1, b } = bm25;
-  if (k1 !== void 0 && (!Number.isFinite(k1) || k1 < 0)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "bm25.k1 must be a finite number at or above 0", { k1 });
-  }
-  if (b !== void 0 && (!Number.isFinite(b) || b < 0 || b > 1)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, "bm25.b must be between 0 and 1", { b });
-  }
-}
-function clampLimit(limit) {
-  return clampRowCount(limit, DEFAULT_LIMIT);
-}
-function clampOffset(offset) {
-  return clampRowCount(offset, DEFAULT_OFFSET);
-}
-
 // src/engine/index-lifecycle.ts
 async function createEngineIndex(core, config, name, indexConfig, indexUuid) {
   core.guardShutdown();
@@ -7144,7 +7498,7 @@ async function insertDocument(ctx, indexName, document, docId, options) {
     }
   }
   ctx.checkWatermark(indexName);
-  await ctx.orchestrator.checkPromotion();
+  await ctx.orchestrator.scaleOutReadyIndexes();
   return resolvedDocId;
 }
 
@@ -7298,7 +7652,6 @@ async function applyAdmittedDocuments(ctx, indexName, admitted, options, failed)
 }
 
 // src/engine/mutations/segment-replication.ts
-var MIN_DOCUMENTS_FOR_SEGMENTS = 64;
 function shardCount(documentCount, workers) {
   if (workers <= 1) return 1;
   return Math.max(1, Math.min(workers, Math.ceil(documentCount / MIN_DOCUMENTS_FOR_SEGMENTS)));
@@ -7558,7 +7911,7 @@ async function insertBatchViaSegments(ctx, indexName, documents, options) {
     vecIndexes.get(fieldPath)?.scheduleBuild();
   }
   ctx.checkWatermark(indexName);
-  await ctx.orchestrator.checkPromotion();
+  await ctx.orchestrator.scaleOutReadyIndexes();
   return { succeeded: outcome.succeeded, failed };
 }
 
@@ -7566,7 +7919,7 @@ async function insertBatchViaSegments(ctx, indexName, documents, options) {
 async function insertDocumentBatch(ctx, indexName, documents, options) {
   ctx.guardShutdown();
   const entry = ctx.requireIndex(indexName);
-  await ctx.orchestrator.promoteBeforeBatch(indexName, documents.length);
+  await ctx.orchestrator.scaleOutBeforeBatch(indexName, documents.length);
   if (documents.length >= MIN_DOCUMENTS_FOR_SEGMENTS && !ctx.isRebalancing(indexName) && ctx.orchestrator.segmentBuildConcurrency(indexName) > 0) {
     return insertBatchViaSegments(ctx, indexName, documents, options);
   }
@@ -7720,7 +8073,7 @@ async function insertDocumentBatch(ctx, indexName, documents, options) {
     }
   }
   ctx.checkWatermark(indexName);
-  await ctx.orchestrator.checkPromotion();
+  await ctx.orchestrator.scaleOutReadyIndexes();
   return { succeeded, failed };
 }
 
@@ -7995,7 +8348,7 @@ async function updateDocumentBatch(ctx, indexName, updates) {
 }
 
 // src/partitioning/write-ahead-queue.ts
-function createWriteAheadQueue(maxSize = 1e4) {
+function createWriteAheadQueue(maxSize = DEFAULT_WRITE_AHEAD_QUEUE_MAX_SIZE) {
   const entries = [];
   const docStates = /* @__PURE__ */ new Map();
   let nextSequence = 1;
@@ -9830,11 +10183,6 @@ async function resolveVectorText(params, embeddingAdapter, signal, embeddingAdap
 }
 
 // src/engine/suggest.ts
-var DEFAULT_SUGGEST_LIMIT = 10;
-var MAX_SUGGEST_LIMIT = 100;
-var SUGGEST_OVERSAMPLE_FACTOR = 1.5;
-var SUGGEST_OVERSAMPLE_PADDING = 10;
-var MAX_SUGGEST_SCATTER_LIMIT = Math.ceil(MAX_SUGGEST_LIMIT * SUGGEST_OVERSAMPLE_FACTOR) + SUGGEST_OVERSAMPLE_PADDING;
 function executeSuggest(manager, language, params, partitionIds) {
   const t0 = performance.now();
   const ceiling = partitionIds === void 0 ? MAX_SUGGEST_LIMIT : MAX_SUGGEST_SCATTER_LIMIT;
@@ -9912,7 +10260,7 @@ async function runEngineQuery(core, indexName, params, options) {
       entry.embeddingAdapterName
     );
     await core.pluginRegistry.runHook("beforeSearch", { indexName, params: resolvedParams });
-    const workerSearch = core.orchestrator.isPromoted() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
+    const workerSearch = core.orchestrator.hasWorkerPool() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
     const result = await executeQuery(resolvedParams, {
       manager,
       language: entry.language,
@@ -9952,7 +10300,7 @@ async function runEnginePreflight(core, indexName, params, options) {
       core.abortController.signal,
       entry.embeddingAdapterName
     );
-    const workerSearch = core.orchestrator.isPromoted() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
+    const workerSearch = core.orchestrator.hasWorkerPool() ? core.orchestrator.searchViaWorker.bind(core.orchestrator) : void 0;
     const result = await executePreflight(resolvedParams, {
       manager,
       language: entry.language,
@@ -10268,6 +10616,7 @@ function createNarsilFromCore(core, config) {
         openIndexCount: lifecycleCounts.open,
         closedIndexCount: lifecycleCounts.closed,
         reopenCount: lifecycleCounts.reopens,
+        workerCopies: orchestrator.workerCopies(),
         workers
       };
     },
@@ -10332,4 +10681,4 @@ async function createNarsil(config) {
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, VERSION, WIRE_BATCH_BUDGET, applyDeleteEntry, applyIndexEntry, chunkByBudget, clampLimit, computeEntryChecksum, createAckMessage, createDurableDirectory, createEngineCore, createEngineIndex, createEntryBatchMessage, createEntryMessage, createForwardBatchMessage, createForwardBatchResultMessage, createForwardMessage, createInsyncAddMessage, createInsyncConfirmMessage, createInsyncRemoveMessage, createNarsil, createNarsilFromCore, dedupePinnedEntries, foldGroupReducer, listBindingOf, now, queryBindingOf, runEngineListDocuments, runEnginePreflight, runEngineQuery, runEngineQueryStats, runEngineSuggest, validateAckPayload, validateEntryBatchPayload, validateEntryPayload, validateForwardBatchPayload, validateForwardBatchResultPayload, validateInsyncConfirmPayload, validateReplicationEntry, writeSegmentedCheckpoint };
+export { VERSION, applyDeleteEntry, applyIndexEntry, 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 };