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

package/dist/index.browser.mjs

@@ -202,6 +202,20 @@ function resolveIndexAnalysis(config) {
   };
 }
 
+// src/core/tokenizer/constants.ts
+var TOKEN_CACHE_SIZE_FLOOR = 5e4;
+var TOKEN_CACHE_SIZE_CEILING = 2e6;
+var TOKEN_CACHE_BYTES_PER_ENTRY = 200;
+var NODE_TOKEN_CACHE_ENTRIES = 1e6;
+var UNKNOWN_MEMORY_TOKEN_CACHE_ENTRIES = 2e5;
+var CONSTRAINED_MEMORY_TOKEN_CACHE_FRACTION = 0.05;
+var SMALL_DEVICE_MEMORY_GB = 1;
+var MEDIUM_DEVICE_MEMORY_GB = 4;
+var SMALL_DEVICE_TOKEN_CACHE_ENTRIES = 1e5;
+var MEDIUM_DEVICE_TOKEN_CACHE_ENTRIES = 25e4;
+var LARGE_DEVICE_TOKEN_CACHE_ENTRIES = 5e5;
+var DEFAULT_MIN_TOKEN_LENGTH = 1;
+
 // src/core/tokenizer/normalize.ts
 var DOTTED_CAPITAL_I = "\u0130";
 var COMBINING_DOT_ABOVE = "\u0307";
@@ -248,37 +262,33 @@ function stripDiacritics(text) {
 }
 
 // src/core/tokenizer/cache.ts
-var CACHE_SIZE_FLOOR = 5e4;
-var CACHE_SIZE_CEILING = 2e6;
-var BYTES_PER_ENTRY = 200;
-var NODE_CACHE_ENTRIES = 1e6;
-var UNKNOWN_MEMORY_CACHE_ENTRIES = 2e5;
 function clampCacheSize(entries) {
-  return Math.max(CACHE_SIZE_FLOOR, Math.min(entries, CACHE_SIZE_CEILING));
+  return Math.max(TOKEN_CACHE_SIZE_FLOOR, Math.min(entries, TOKEN_CACHE_SIZE_CEILING));
 }
 function computeDefaultCacheSize() {
   try {
     if (typeof process !== "undefined" && typeof process.versions?.node === "string" && typeof window === "undefined") {
       const constrainedMemory = typeof process.constrainedMemory === "function" ? process.constrainedMemory() : 0;
       if (constrainedMemory > 0) {
-        return clampCacheSize(Math.floor(constrainedMemory * 0.05 / BYTES_PER_ENTRY));
+        const budget = constrainedMemory * CONSTRAINED_MEMORY_TOKEN_CACHE_FRACTION;
+        return clampCacheSize(Math.floor(budget / TOKEN_CACHE_BYTES_PER_ENTRY));
       }
-      return clampCacheSize(NODE_CACHE_ENTRIES);
+      return clampCacheSize(NODE_TOKEN_CACHE_ENTRIES);
     }
     if (typeof navigator !== "undefined") {
       const mem = navigator.deviceMemory;
       if (typeof mem === "number" && mem > 0) {
         let entries;
-        if (mem <= 1) entries = 1e5;
-        else if (mem <= 4) entries = 25e4;
-        else entries = 5e5;
+        if (mem <= SMALL_DEVICE_MEMORY_GB) entries = SMALL_DEVICE_TOKEN_CACHE_ENTRIES;
+        else if (mem <= MEDIUM_DEVICE_MEMORY_GB) entries = MEDIUM_DEVICE_TOKEN_CACHE_ENTRIES;
+        else entries = LARGE_DEVICE_TOKEN_CACHE_ENTRIES;
         return clampCacheSize(entries);
       }
     }
   } catch {
-    return clampCacheSize(UNKNOWN_MEMORY_CACHE_ENTRIES);
+    return clampCacheSize(UNKNOWN_MEMORY_TOKEN_CACHE_ENTRIES);
   }
-  return clampCacheSize(UNKNOWN_MEMORY_CACHE_ENTRIES);
+  return clampCacheSize(UNKNOWN_MEMORY_TOKEN_CACHE_ENTRIES);
 }
 var normalizationCache = /* @__PURE__ */ new Map();
 var normalizationCacheSize = 0;
@@ -306,7 +316,7 @@ function configureNormalizationCache(maxSize) {
       }
     );
   }
-  maxCacheSize = Math.max(CACHE_SIZE_FLOOR, Math.min(Math.floor(maxSize), CACHE_SIZE_CEILING));
+  maxCacheSize = Math.max(TOKEN_CACHE_SIZE_FLOOR, Math.min(Math.floor(maxSize), TOKEN_CACHE_SIZE_CEILING));
   if (normalizationCacheSize > maxCacheSize) {
     evictOldestEntries(normalizationCacheSize - maxCacheSize);
   }
@@ -519,7 +529,6 @@ function expandNgrams(part, size, out) {
 
 // src/core/tokenizer/tokenize.ts
 var DEFAULT_SPLIT_PATTERN = /[^\p{L}\p{M}\p{N}_'-]+/u;
-var DEFAULT_MIN_TOKEN_LENGTH = 1;
 function resolveStopWords(language, override) {
   if (!override) return language.stopWords;
   if (override instanceof Set) return override;
@@ -1830,7 +1839,6 @@ var VECTOR_PATTERN = /^vector\[(\d+)]$/;
 var FIELD_NAME_PATTERN = /^[A-Za-z0-9_]+$/;
 var RESERVED_ROOT_FIELDS = /* @__PURE__ */ new Set(["id"]);
 var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-var MAX_NESTING_DEPTH = 4;
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -2002,8 +2010,11 @@ function validateFieldValue(path, value, type) {
   }
 }
 
-// src/schema/validator/storable.ts
+// src/schema/constants.ts
+var MAX_NESTING_DEPTH = 4;
 var MAX_DOCUMENT_NESTING_DEPTH = 32;
+
+// src/schema/validator/storable.ts
 var RESERVED_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function reject(path, reason) {
   throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path === "" ? "(document)" : path}" ${reason}`, {
@@ -2256,194 +2267,15 @@ function extractVectorFieldsFromSchema(schema) {
   return result;
 }
 
-// src/vector/hnsw/adjacency.ts
+// src/vector/hnsw/constants.ts
 var MAX_LAYER_CAP = 32;
 var MAX_M = 512;
-var ABSENT = -1;
 var INITIAL_UPPER_SLOTS = 64;
-function createAdjacency(m, mMax0) {
-  return {
-    m,
-    mMax0,
-    level0Stride: mMax0 + 2,
-    upperStride: m + 2,
-    capacity: 0,
-    slots: 0,
-    nodeLevels: new Int8Array(0),
-    level0: new Int32Array(0),
-    upperBase: new Int32Array(0),
-    upper: new Int32Array(0),
-    upperUsed: 0,
-    freeBlocks: Array.from({ length: MAX_LAYER_CAP + 1 }, () => [])
-  };
-}
-function ensureAdjacencyCapacity(adj, needed) {
-  if (needed <= adj.capacity) return;
-  let newCapacity = adj.capacity === 0 ? 16 : adj.capacity;
-  while (newCapacity < needed) newCapacity *= 2;
-  const nextLevels = new Int8Array(newCapacity).fill(ABSENT);
-  nextLevels.set(adj.nodeLevels);
-  adj.nodeLevels = nextLevels;
-  const nextLevel0 = new Int32Array(newCapacity * adj.level0Stride);
-  nextLevel0.set(adj.level0);
-  adj.level0 = nextLevel0;
-  const nextUpperBase = new Int32Array(newCapacity).fill(ABSENT);
-  nextUpperBase.set(adj.upperBase);
-  adj.upperBase = nextUpperBase;
-  adj.capacity = newCapacity;
-}
-function allocateUpperBlock(adj, levels) {
-  const reusable = adj.freeBlocks[levels].pop();
-  const size = levels * adj.upperStride;
-  if (reusable !== void 0) {
-    adj.upper.fill(0, reusable, reusable + size);
-    return reusable;
-  }
-  if (adj.upperUsed + size > adj.upper.length) {
-    const required = adj.upperUsed + size;
-    let nextLength = adj.upper.length === 0 ? INITIAL_UPPER_SLOTS * adj.upperStride : adj.upper.length;
-    while (nextLength < required) nextLength *= 2;
-    const nextUpper = new Int32Array(nextLength);
-    nextUpper.set(adj.upper);
-    adj.upper = nextUpper;
-  }
-  const offset = adj.upperUsed;
-  adj.upperUsed += size;
-  adj.upper.fill(0, offset, offset + size);
-  return offset;
-}
-function createNode(adj, ord, maxLayer) {
-  ensureAdjacencyCapacity(adj, ord + 1);
-  if (ord >= adj.slots) adj.slots = ord + 1;
-  const existingLevel = adj.nodeLevels[ord];
-  const existingBase = adj.upperBase[ord];
-  if (existingLevel >= 1 && existingBase !== ABSENT) {
-    adj.freeBlocks[existingLevel].push(existingBase);
-  }
-  adj.nodeLevels[ord] = maxLayer;
-  adj.level0[ord * adj.level0Stride] = 0;
-  adj.upperBase[ord] = maxLayer >= 1 ? allocateUpperBlock(adj, maxLayer) : ABSENT;
-}
-function deleteNode(adj, ord) {
-  if (ord < 0 || ord >= adj.capacity) return;
-  const level = adj.nodeLevels[ord];
-  const base = adj.upperBase[ord];
-  if (level >= 1 && base !== ABSENT) {
-    adj.freeBlocks[level].push(base);
-  }
-  adj.nodeLevels[ord] = ABSENT;
-  adj.upperBase[ord] = ABSENT;
-  adj.level0[ord * adj.level0Stride] = 0;
-}
-function resetAdjacency(adj) {
-  adj.nodeLevels = new Int8Array(0);
-  adj.level0 = new Int32Array(0);
-  adj.upperBase = new Int32Array(0);
-  adj.upper = new Int32Array(0);
-  adj.upperUsed = 0;
-  adj.capacity = 0;
-  adj.slots = 0;
-  for (const list of adj.freeBlocks) list.length = 0;
-}
-function nodeLevel(adj, ord) {
-  if (ord < 0 || ord >= adj.capacity) return ABSENT;
-  return adj.nodeLevels[ord];
-}
-function hasNode(adj, ord) {
-  return nodeLevel(adj, ord) !== ABSENT;
-}
-function layerArray(adj, layer) {
-  return layer === 0 ? adj.level0 : adj.upper;
-}
-function layerBase(adj, ord, layer) {
-  const level = nodeLevel(adj, ord);
-  if (level === ABSENT || layer > level) return ABSENT;
-  if (layer === 0) return ord * adj.level0Stride;
-  const base = adj.upperBase[ord];
-  if (base === ABSENT) return ABSENT;
-  return base + (layer - 1) * adj.upperStride;
-}
-function neighborCount(adj, ord, layer) {
-  const base = layerBase(adj, ord, layer);
-  if (base === ABSENT) return 0;
-  return layerArray(adj, layer)[base];
-}
-function collectNeighbors(adj, ord, layer) {
-  const base = layerBase(adj, ord, layer);
-  if (base === ABSENT) return [];
-  const array = layerArray(adj, layer);
-  const count = array[base];
-  const collected = new Array(count);
-  for (let i = 0; i < count; i++) {
-    collected[i] = array[base + i + 1];
-  }
-  return collected;
-}
-function addNeighbor(adj, ord, layer, neighborOrd) {
-  const base = layerBase(adj, ord, layer);
-  if (base === ABSENT) return;
-  const array = layerArray(adj, layer);
-  const count = array[base];
-  for (let i = 1; i <= count; i++) {
-    if (array[base + i] === neighborOrd) return;
-  }
-  const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
-  if (count + 1 > stride - 1) return;
-  array[base + count + 1] = neighborOrd;
-  array[base] = count + 1;
-}
-function removeNeighbor(adj, ord, layer, neighborOrd) {
-  const base = layerBase(adj, ord, layer);
-  if (base === ABSENT) return;
-  const array = layerArray(adj, layer);
-  const count = array[base];
-  for (let i = 1; i <= count; i++) {
-    if (array[base + i] !== neighborOrd) continue;
-    for (let j = i; j < count; j++) {
-      array[base + j] = array[base + j + 1];
-    }
-    array[base] = count - 1;
-    return;
-  }
-}
-function replaceNeighbors(adj, ord, layer, neighbors, count) {
-  const base = layerBase(adj, ord, layer);
-  if (base === ABSENT) return;
-  const array = layerArray(adj, layer);
-  const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
-  const limit = Math.min(count, stride - 1);
-  for (let i = 0; i < limit; i++) {
-    array[base + i + 1] = neighbors[i];
-  }
-  array[base] = limit;
-}
-function exportAdjacency(adj) {
-  return {
-    m: adj.m,
-    mMax0: adj.mMax0,
-    capacity: adj.capacity,
-    slots: adj.slots,
-    upperUsed: adj.upperUsed,
-    nodeLevels: adj.nodeLevels.slice(),
-    level0: adj.level0.slice(),
-    upperBase: adj.upperBase.slice(),
-    upper: adj.upper.slice(0, adj.upperUsed)
-  };
-}
-function importAdjacency(snapshot) {
-  const adj = createAdjacency(snapshot.m, snapshot.mMax0);
-  adj.capacity = snapshot.capacity;
-  adj.slots = snapshot.slots;
-  adj.upperUsed = snapshot.upperUsed;
-  adj.nodeLevels = snapshot.nodeLevels;
-  adj.level0 = snapshot.level0;
-  adj.upperBase = snapshot.upperBase;
-  adj.upper = snapshot.upper;
-  return adj;
-}
-function estimateAdjacencyBytes(adj) {
-  return adj.nodeLevels.byteLength + adj.level0.byteLength + adj.upperBase.byteLength + adj.upper.byteLength;
-}
+var INITIAL_LIST_CAPACITY = 64;
+var COMPACTION_TOMBSTONE_RATIO = 0.1;
+var COMPACTION_ABSOLUTE_THRESHOLD = 1e3;
+var SQ8_OVERSELECTION_FACTOR = 2;
+var SQ8_RERANK_FLOOR = 10;
 
 // src/schema/validator/vector-promotion.ts
 function fail(message, details) {
@@ -2476,6 +2308,11 @@ function validateVectorPromotion(config) {
     fail("vectorPromotion.hnswConfig.metric must be 'cosine', 'dotProduct', or 'euclidean'", { metric });
   }
 }
+
+// src/serialization/constants.ts
+var CHECKSUM_TIMEOUT_MS = 12e4;
+var CHECKSUM_YIELD_CHUNK_BYTES = 4 * 1024 * 1024;
+var VALID_HNSW_METRICS = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
 function metadataToWire(meta) {
   const wire = {
     index_name: meta.indexName,
@@ -2718,7 +2555,6 @@ function sanitizeSurfaceForms(raw) {
   }
   return count > 0 ? result : void 0;
 }
-var VALID_HNSW_METRICS = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
 function validateHnswMetric(value) {
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
@@ -2816,10 +2652,9 @@ function deserializePayloadV1(data) {
 function encodeRawPayloadV2(wire) {
   return encode(wire);
 }
-var VALID_HNSW_METRICS2 = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
 function validateHnswMetric2(value) {
   if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string" && VALID_HNSW_METRICS2.has(value)) {
+  if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
     return value;
   }
   return void 0;
@@ -3023,8 +2858,10 @@ function compareSortStrings(a, b) {
   return compareCodePoints(a, b);
 }
 
-// src/core/ordering/sort-values.ts
+// src/core/ordering/constants.ts
 var SORT_VALUE_MAX_CODE_POINTS = 512;
+
+// src/core/ordering/sort-values.ts
 function truncateSortString(value) {
   if (value.length <= SORT_VALUE_MAX_CODE_POINTS) return value;
   let index = 0;
@@ -3344,6 +3181,11 @@ function createDocumentStore() {
   };
 }
 
+// src/core/constants.ts
+var POSTING_LIST_INITIAL_CAPACITY = 8;
+var POSTING_LIST_COMPACTION_THRESHOLD = 0.3;
+var MAX_TERM_FREQUENCY = 65535;
+
 // src/core/fuzzy.ts
 function boundedLevenshtein(a, b, tolerance) {
   if (tolerance < 0) return { distance: -1, withinTolerance: false };
@@ -3394,15 +3236,12 @@ function boundedLevenshtein(a, b, tolerance) {
 }
 
 // src/core/posting-list.ts
-var INITIAL_CAPACITY = 8;
-var MAX_TERM_FREQUENCY = 65535;
-var COMPACTION_THRESHOLD = 0.3;
 function createPostingList() {
   return {
     length: 0,
     docIds: [],
-    termFrequencies: new Uint16Array(INITIAL_CAPACITY),
-    fieldNameIndices: new Uint8Array(INITIAL_CAPACITY),
+    termFrequencies: new Uint16Array(POSTING_LIST_INITIAL_CAPACITY),
+    fieldNameIndices: new Uint8Array(POSTING_LIST_INITIAL_CAPACITY),
     positions: null,
     docIdSet: /* @__PURE__ */ new Set(),
     deletedDocs: /* @__PURE__ */ new Set(),
@@ -3570,7 +3409,7 @@ function createInvertedIndex(fieldNameTable) {
         batchDirtyTokens.add(token);
         return;
       }
-      if (list.deletedDocs.size / list.length > COMPACTION_THRESHOLD) {
+      if (list.deletedDocs.size / list.length > POSTING_LIST_COMPACTION_THRESHOLD) {
         compactList(list);
       }
     },
@@ -3583,7 +3422,7 @@ function createInvertedIndex(fieldNameTable) {
       for (const token of batchDirtyTokens) {
         const list = index.get(token);
         if (!list) continue;
-        if (list.deletedDocs.size / list.length > COMPACTION_THRESHOLD) {
+        if (list.deletedDocs.size / list.length > POSTING_LIST_COMPACTION_THRESHOLD) {
           compactList(list);
         }
       }
@@ -4335,9 +4174,13 @@ function computeFacets(state, matched, config, schema) {
   return result;
 }
 
+// src/geo/constants.ts
+var DEG_TO_RAD = Math.PI / 180;
+var VINCENTY_MAX_ITERATIONS = 200;
+var VINCENTY_CONVERGENCE_THRESHOLD = 1e-12;
+
 // src/geo/haversine.ts
 var EARTH_RADIUS_METERS = 63710088e-1;
-var DEG_TO_RAD = Math.PI / 180;
 function haversineDistance(lat1, lon1, lat2, lon2) {
   const phi1 = lat1 * DEG_TO_RAD;
   const phi2 = lat2 * DEG_TO_RAD;
@@ -4375,13 +4218,10 @@ function isPointInPolygon(lat, lon, polygon) {
 var WGS84_A = 6378137;
 var WGS84_F = 1 / 298.257223563;
 var WGS84_B = WGS84_A * (1 - WGS84_F);
-var DEG_TO_RAD2 = Math.PI / 180;
-var MAX_ITERATIONS = 200;
-var CONVERGENCE_THRESHOLD = 1e-12;
 function vincentyDistance(lat1, lon1, lat2, lon2) {
-  const phi1 = lat1 * DEG_TO_RAD2;
-  const phi2 = lat2 * DEG_TO_RAD2;
-  const L = (lon2 - lon1) * DEG_TO_RAD2;
+  const phi1 = lat1 * DEG_TO_RAD;
+  const phi2 = lat2 * DEG_TO_RAD;
+  const L = (lon2 - lon1) * DEG_TO_RAD;
   const U1 = Math.atan((1 - WGS84_F) * Math.tan(phi1));
   const U2 = Math.atan((1 - WGS84_F) * Math.tan(phi2));
   const sinU1 = Math.sin(U1);
@@ -4396,7 +4236,7 @@ function vincentyDistance(lat1, lon1, lat2, lon2) {
   let sinAlpha = 0;
   let cos2Alpha = 0;
   let cos2SigmaM = 0;
-  let iterations = MAX_ITERATIONS;
+  let iterations = VINCENTY_MAX_ITERATIONS;
   do {
     const sinLambda = Math.sin(lambda);
     const cosLambda = Math.cos(lambda);
@@ -4412,7 +4252,7 @@ function vincentyDistance(lat1, lon1, lat2, lon2) {
     const C = WGS84_F / 16 * cos2Alpha * (4 + WGS84_F * (4 - 3 * cos2Alpha));
     prevLambda = lambda;
     lambda = L + (1 - C) * WGS84_F * sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
-  } while (Math.abs(lambda - prevLambda) > CONVERGENCE_THRESHOLD && --iterations > 0);
+  } while (Math.abs(lambda - prevLambda) > VINCENTY_CONVERGENCE_THRESHOLD && --iterations > 0);
   if (iterations === 0) {
     return haversineDistance(lat1, lon1, lat2, lon2);
   }
@@ -5697,14 +5537,27 @@ function partitionFilterMatches(state, filters, schema) {
   };
 }
 
+// src/core/partition/posting-columns.ts
+function postingColumns(list) {
+  const deletedDocs = list.deletedDocs;
+  return {
+    docIds: list.docIds,
+    termFrequencies: list.termFrequencies,
+    fieldNameIndices: list.fieldNameIndices,
+    deletedDocs,
+    hasDeleted: deletedDocs.size > 0,
+    count: list.length
+  };
+}
+
 // src/core/partition/matches.ts
 function markPostingList(matched, list, fieldNames, fields, filterBitset) {
-  const hasDeleted = list.deletedDocs.size > 0;
-  for (let pi = 0; pi < list.length; pi++) {
-    const internalId = list.docIds[pi];
-    if (hasDeleted && list.deletedDocs.has(internalId)) continue;
+  const { docIds, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(list);
+  for (let pi = 0; pi < count; pi++) {
+    const internalId = docIds[pi];
+    if (hasDeleted && deletedDocs.has(internalId)) continue;
     if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-    if (fields && !fields.includes(fieldNames[list.fieldNameIndices[pi]])) continue;
+    if (fields && !fields.includes(fieldNames[fieldNameIndices[pi]])) continue;
     bitsetSet(matched, internalId);
   }
 }
@@ -5775,6 +5628,12 @@ function searchFulltextMatches(state, params) {
   };
 }
 
+// src/core/partition/constants.ts
+var TARGET_BLOCK_ENTRIES = 128;
+var SCORE_BUFFER_INITIAL_TOUCHED_CAPACITY = 1024;
+var SORT_COLUMN_MINIMUM_REBUILD_THRESHOLD = 1024;
+var SORT_COLUMN_REBUILD_FRACTION_SHIFT = 2;
+
 // src/core/partition/sort-columns/order.ts
 var MISSING_RANK = -1;
 var BYTES_PER_RANK = 4;
@@ -6000,8 +5859,6 @@ function createValueStore(initialKind) {
 }
 
 // src/core/partition/sort-columns/index.ts
-var MINIMUM_REBUILD_THRESHOLD = 1024;
-var REBUILD_FRACTION_SHIFT = 2;
 function liveInternalIds(docStore) {
   const ids = [];
   for (const internalId of docStore.allInternalIds()) ids.push(internalId);
@@ -6011,8 +5868,8 @@ function createSortColumnSet(docStore) {
   const columns = /* @__PURE__ */ new Map();
   function rebuildThreshold() {
     const count = docStore.count();
-    const fraction = count >> REBUILD_FRACTION_SHIFT;
-    return fraction > MINIMUM_REBUILD_THRESHOLD ? fraction : MINIMUM_REBUILD_THRESHOLD;
+    const fraction = count >> SORT_COLUMN_REBUILD_FRACTION_SHIFT;
+    return fraction > SORT_COLUMN_MINIMUM_REBUILD_THRESHOLD ? fraction : SORT_COLUMN_MINIMUM_REBUILD_THRESHOLD;
   }
   function rebuild2(entry) {
     entry.order = buildOrder(entry.store, docStore.allInternalIds(), docStore.internalIdCapacity());
@@ -6641,13 +6498,12 @@ function sortSelection(heap) {
 }
 
 // src/core/partition/score-buffer.ts
-var INITIAL_TOUCHED_CAPACITY = 1024;
 var MAX_GENERATION = 2147483647;
 function createScoreBuffer(capacity) {
   return {
     scores: new Float64Array(capacity),
     stamps: new Int32Array(capacity),
-    touched: new Int32Array(Math.max(1, Math.min(capacity, INITIAL_TOUCHED_CAPACITY))),
+    touched: new Int32Array(Math.max(1, Math.min(capacity, SCORE_BUFFER_INITIAL_TOUCHED_CAPACITY))),
     touchedCount: 0,
     generation: 0
   };
@@ -6732,7 +6588,6 @@ function topKFromBuffer(buffer, k, resolver, components) {
 }
 
 // src/core/partition/block-bounds.ts
-var TARGET_BLOCK_ENTRIES = 128;
 var ABSENT_FIELD_LENGTH_BOUND = 0;
 var boundsByList = /* @__PURE__ */ new WeakMap();
 function fieldLengthBound(columns, fieldIndex, internalId) {
@@ -6841,12 +6696,27 @@ function bestSearchable(searchable, values) {
   }
   return best;
 }
+function prunableSingleTermList(params, index) {
+  if (params.queryTokens.length !== 1) return null;
+  if (params.prefixExpansion !== void 0) return null;
+  if (params.exact !== true && (params.tolerance ?? 0) !== 0) return null;
+  if (params.termMatch !== void 0 && params.termMatch !== "any") return null;
+  if (params.collectComponents !== false) return null;
+  if (params.collectMatchedSet !== void 0) return null;
+  if (params.maxResults === void 0) return null;
+  if (params.fields !== void 0) return null;
+  if (params.filterBitset !== void 0) return null;
+  if (!bm25PruningSound(params.bm25Params)) return null;
+  const list = index.lookup(params.queryTokens[0].token);
+  if (list === void 0) return null;
+  if (!list.ordered) return null;
+  return list;
+}
 function singleTermTopK(request) {
   const { list, docFrequency, totalDocs, bm25Params, limit, resolver } = request;
   const { fieldSearchable, fieldBoosts, fieldAvgLengths, fieldLengthColumns } = request;
   const wanted = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
-  const deleted = list.deletedDocs;
-  const hasDeleted = deleted.size > 0;
+  const { docIds, termFrequencies, fieldNameIndices, deletedDocs: deleted, hasDeleted } = postingColumns(list);
   const bounds = blockBoundsFor(list, fieldLengthColumns);
   const maxBoost = bestSearchable(fieldSearchable, fieldBoosts);
   const maxAverageLength = bestSearchable(fieldSearchable, fieldAvgLengths);
@@ -6873,19 +6743,19 @@ function singleTermTopK(request) {
     }
     let entry = start;
     while (entry < end) {
-      const internalId = list.docIds[entry];
+      const internalId = docIds[entry];
       if (hasDeleted && deleted.has(internalId)) {
-        while (entry < end && list.docIds[entry] === internalId) entry++;
+        while (entry < end && docIds[entry] === internalId) entry++;
         continue;
       }
       let score = 0;
       let scored2 = false;
-      while (entry < end && list.docIds[entry] === internalId) {
-        const fieldIndex = list.fieldNameIndices[entry];
+      while (entry < end && docIds[entry] === internalId) {
+        const fieldIndex = fieldNameIndices[entry];
         if (fieldSearchable[fieldIndex] === 1) {
           const fieldLength = fieldLengthOf(fieldLengthColumns, fieldIndex, internalId, fieldAvgLengths[fieldIndex]);
           score += computeBM25(
-            list.termFrequencies[entry],
+            termFrequencies[entry],
             docFrequency,
             totalDocs,
             fieldLength,
@@ -6937,21 +6807,10 @@ function singleTermTopK(request) {
 function globalDocFreqFor(docFreqs, term, fallback) {
   return Object.hasOwn(docFreqs, term) ? docFreqs[term] : fallback;
 }
-function prunableSingleTermList(params, index) {
-  if (params.queryTokens.length !== 1) return null;
-  if (params.prefixExpansion !== void 0) return null;
-  if (params.exact !== true && (params.tolerance ?? 0) !== 0) return null;
-  if (params.termMatch !== void 0 && params.termMatch !== "any") return null;
-  if (params.collectComponents !== false) return null;
-  if (params.collectMatchedSet !== void 0) return null;
-  if (params.maxResults === void 0) return null;
-  if (params.fields !== void 0) return null;
-  if (params.filterBitset !== void 0) return null;
-  if (!bm25PruningSound(params.bm25Params)) return null;
-  const list = index.lookup(params.queryTokens[0].token);
-  if (list === void 0) return null;
-  if (!list.ordered) return null;
-  return list;
+function matchesFor(index, token, exact, tolerance, prefixLength) {
+  if (!exact) return index.fuzzyLookup(token, tolerance, prefixLength);
+  const postingList = index.lookup(token);
+  return postingList ? [{ token, postingList }] : [];
 }
 function searchFulltext(state, params) {
   const {
@@ -7032,17 +6891,18 @@ function searchFulltext(state, params) {
     const best = /* @__PURE__ */ new Map();
     for (const match of matches) {
       const perTerm = /* @__PURE__ */ new Map();
-      const list = match.postingList;
-      const hasDeleted = list.deletedDocs.size > 0;
-      for (let pi = 0; pi < list.length; pi++) {
-        const internalId = list.docIds[pi];
-        if (hasDeleted && list.deletedDocs.has(internalId)) continue;
+      const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
+        match.postingList
+      );
+      for (let pi = 0; pi < count; pi++) {
+        const internalId = docIds[pi];
+        if (hasDeleted && deletedDocs.has(internalId)) continue;
         if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-        const fieldIndex = list.fieldNameIndices[pi];
+        const fieldIndex = fieldNameIndices[pi];
         loadFieldMeta(fieldIndex);
         if (fieldSearchable[fieldIndex] === 0) continue;
         const fieldName = fieldNames[fieldIndex];
-        const termFrequency = list.termFrequencies[pi];
+        const termFrequency = termFrequencies[pi];
         const fieldBoost = fieldBoosts[fieldIndex];
         const avgLen = fieldAvgLengths[fieldIndex];
         const actualFieldLength = resolveFieldLength(internalId, fieldIndex, avgLen);
@@ -7114,10 +6974,7 @@ function searchFulltext(state, params) {
         resolved.push({ token: qt.token, matches: [], totalPostings: totalPostings2, isPrefix: true });
         continue;
       }
-      const rawMatches = exact ? (() => {
-        const postingList = state.invertedIdx.lookup(qt.token);
-        return postingList ? [{ token: qt.token, postingList }] : [];
-      })() : state.invertedIdx.fuzzyLookup(qt.token, tolerance, prefixLength);
+      const rawMatches = matchesFor(state.invertedIdx, qt.token, exact, tolerance, prefixLength);
       let totalPostings = 0;
       const matches = [];
       for (const m of rawMatches) {
@@ -7139,17 +6996,18 @@ function searchFulltext(state, params) {
         continue;
       }
       for (const match of resolved[tokenIndex].matches) {
-        const list = match.postingList;
-        const hasDeleted = list.deletedDocs.size > 0;
-        for (let pi = 0; pi < list.length; pi++) {
-          const internalId = list.docIds[pi];
-          if (hasDeleted && list.deletedDocs.has(internalId)) continue;
+        const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
+          match.postingList
+        );
+        for (let pi = 0; pi < count; pi++) {
+          const internalId = docIds[pi];
+          if (hasDeleted && deletedDocs.has(internalId)) continue;
           if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
           if (tokenIndex > 0 && !hasScore(scoreBuffer, internalId)) continue;
-          const fieldIndex = list.fieldNameIndices[pi];
+          const fieldIndex = fieldNameIndices[pi];
           loadFieldMeta(fieldIndex);
           if (fieldSearchable[fieldIndex] === 0) continue;
-          const termFrequency = list.termFrequencies[pi];
+          const termFrequency = termFrequencies[pi];
           const fieldBoost = fieldBoosts[fieldIndex];
           const avgLen = fieldAvgLengths[fieldIndex];
           const actualFieldLength = resolveFieldLength(internalId, fieldIndex, avgLen);
@@ -7182,23 +7040,21 @@ function searchFulltext(state, params) {
         }
         continue;
       }
-      const matchingPostings = exact ? (() => {
-        const postingList = state.invertedIdx.lookup(qt.token);
-        return postingList ? [{ token: qt.token, postingList }] : [];
-      })() : state.invertedIdx.fuzzyLookup(qt.token, tolerance, prefixLength);
+      const matchingPostings = matchesFor(state.invertedIdx, qt.token, exact, tolerance, prefixLength);
       for (const match of matchingPostings) {
         const docFreq = globalStats ? globalDocFreqFor(globalDocFreqs, match.token, match.postingList.docIdSet.size) : match.postingList.docIdSet.size;
         const idf = computeIDF(docFreq, totalDocs);
-        const list = match.postingList;
-        const hasDeleted = list.deletedDocs.size > 0;
-        for (let pi = 0; pi < list.length; pi++) {
-          const internalId = list.docIds[pi];
-          if (hasDeleted && list.deletedDocs.has(internalId)) continue;
+        const { docIds, termFrequencies, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(
+          match.postingList
+        );
+        for (let pi = 0; pi < count; pi++) {
+          const internalId = docIds[pi];
+          if (hasDeleted && deletedDocs.has(internalId)) continue;
           if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-          const fieldIndex = list.fieldNameIndices[pi];
+          const fieldIndex = fieldNameIndices[pi];
           loadFieldMeta(fieldIndex);
           if (fieldSearchable[fieldIndex] === 0) continue;
-          const termFrequency = list.termFrequencies[pi];
+          const termFrequency = termFrequencies[pi];
           const fieldBoost = fieldBoosts[fieldIndex];
           const avgLen = fieldAvgLengths[fieldIndex];
           const actualFieldLength = resolveFieldLength(internalId, fieldIndex, avgLen);
@@ -8111,8 +7967,11 @@ function createPartitionIndex(partitionId, trackPositions = true) {
   return partition;
 }
 
+// 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;
@@ -8175,7 +8034,7 @@ function createRebalancer() {
             documentsProcessed++;
           }
           chunkFill++;
-          if (chunkFill >= CHUNK_SIZE) {
+          if (chunkFill >= REBALANCE_CHUNK_SIZE) {
             chunkFill = 0;
             onProgress?.({
               phase: "moving",
@@ -9152,6 +9011,9 @@ function createFrozenTombstones() {
       removed.add(internalId);
       revision++;
       return true;
+    },
+    values() {
+      return removed.values();
     }
   };
 }
@@ -9275,7 +9137,7 @@ function buildGeoReaders(entries) {
   }
   return readers;
 }
-function assembleFrozenSegment(segmentId, source, documentSource) {
+function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot) {
   const tombstones = createFrozenTombstones();
   const postingViews = createFrozenPostingViews(source, tombstones);
   const lengthColumns = /* @__PURE__ */ new Map();
@@ -9296,6 +9158,7 @@ function assembleFrozenSegment(segmentId, source, documentSource) {
   const segment = {
     segmentId,
     documentSource,
+    sharedSnapshot,
     invertedIdx: createFrozenInvertedReader(source.tokenTable, postingViews),
     docStore,
     stats: buildStatsView(source),
@@ -9326,6 +9189,11 @@ function assembleFrozenSegment(segmentId, source, documentSource) {
         segment.scoreBuffer = null;
       }
       return added;
+    },
+    tombstonedDocIds() {
+      const docIds = [];
+      for (const ordinal of tombstones.values()) docIds.push(source.idTable.idAt(ordinal));
+      return docIds;
     }
   };
   return segment;
@@ -9339,7 +9207,8 @@ function createFrozenSegment(payload, documents, segmentId) {
       idTable: buildExternalIdTable(payload.docIds),
       docFrequencies: () => payload.docFrequencies
     },
-    wrapDocumentArray(documents)
+    wrapDocumentArray(documents),
+    null
   );
 }
 function createSharedFrozenSegment(snapshot) {
@@ -9358,7 +9227,8 @@ function createSharedFrozenSegment(snapshot) {
         return frequencies;
       }
     },
-    wrapEncodedDocumentTable(snapshot.documentTable)
+    wrapEncodedDocumentTable(snapshot.documentTable),
+    snapshot
   );
 }
 
@@ -9400,6 +9270,15 @@ function buildCompactedSegmentPayload(segments) {
   }
   return { payload: scratch.encodeSegment(), documents };
 }
+function freezeLiveTailInto(live, liveState, frozen, freeze) {
+  if (live.count() === 0) return null;
+  const payload = live.encodeSegment();
+  const segment = freeze(payload, survivorDocumentsOf(liveState, payload));
+  if (segment === null) return null;
+  live.clear();
+  frozen.push(segment);
+  return segment;
+}
 function swapFrozenSegmentList(frozen, dropSegmentIds, replacement, partitionId) {
   const dropped = resolveFrozenSegments(frozen, dropSegmentIds, partitionId);
   const dropSet = new Set(dropSegmentIds);
@@ -9439,11 +9318,15 @@ function subBitsetView(composite, layout, subIndex) {
   const endWord = subIndex + 1 < layout.bases.length ? layout.bases[subIndex + 1] >> 5 : Math.ceil(layout.totalCapacity / WORD_BITS);
   return composite.subarray(startWord, endWord);
 }
+function placeSubBitset(composite, layout, subIndex, subBits) {
+  const words = subBitsetView(composite, layout, subIndex).length;
+  if (words === 0) return;
+  composite.set(subBits.length > words ? subBits.subarray(0, words) : subBits, layout.bases[subIndex] >> 5);
+}
 function compositeFiltersBitset(subs, layout, filters, schema) {
   const composite = new Uint32Array(Math.ceil(layout.totalCapacity / WORD_BITS));
   for (let i = 0; i < subs.length; i++) {
-    const subBits = applyPartitionFiltersBitset(subs[i], filters, schema);
-    composite.set(subBits, layout.bases[i] >> 5);
+    placeSubBitset(composite, layout, i, applyPartitionFiltersBitset(subs[i], filters, schema));
   }
   return composite;
 }
@@ -9705,10 +9588,30 @@ function subParams(params, layout, subIndex, globalStats) {
     filterBitset: params.filterBitset === void 0 ? void 0 : subBitsetView(params.filterBitset, layout, subIndex)
   };
 }
+function onlyPopulatedSub(subs) {
+  let found = -1;
+  for (let i = 0; i < subs.length; i++) {
+    if (subs[i].stats.totalDocuments === 0) continue;
+    if (found !== -1) return -1;
+    found = i;
+  }
+  return found;
+}
+function searchSingleSub(subs, layout, params, index) {
+  const result = searchFulltext(subs[index], subParams(params, layout, index, params.globalStats));
+  if (result.matchedOrdinalBitset === void 0) return result;
+  const matchedOrdinalBitset = createBitSet(layout.totalCapacity);
+  placeSubBitset(matchedOrdinalBitset, layout, index, result.matchedOrdinalBitset);
+  return { ...result, matchedOrdinalBitset };
+}
 function compositeSearchFulltext(subs, layout, params) {
   if (params.queryTokens.length === 0) {
     return { scored: [], totalMatched: 0 };
   }
+  const single = onlyPopulatedSub(subs);
+  if (single !== -1) {
+    return searchSingleSub(subs, layout, params, single);
+  }
   const globalStats = compositeQueryStats(subs, params);
   const results = subs.map((sub, index) => searchFulltext(sub, subParams(params, layout, index, globalStats)));
   const scored = kWayMerge(results.map((result) => result.scored));
@@ -9726,7 +9629,7 @@ function compositeSearchFulltext(subs, layout, params) {
     const matchedOrdinalBitset = createBitSet(layout.totalCapacity);
     for (let i = 0; i < results.length; i++) {
       const subBitset = results[i].matchedOrdinalBitset;
-      if (subBitset !== void 0) matchedOrdinalBitset.set(subBitset, layout.bases[i] >> 5);
+      if (subBitset !== void 0) placeSubBitset(matchedOrdinalBitset, layout, i, subBitset);
     }
     return { scored, totalMatched, matchedOrdinalBitset };
   }
@@ -9770,7 +9673,7 @@ function compositeSearchMatches(subs, layout, params) {
     ordinalBitset() {
       const combined = createBitSet(layout.totalCapacity);
       for (let i = 0; i < subMatches.length; i++) {
-        combined.set(subMatches[i].ordinalBitset(), layout.bases[i] >> 5);
+        placeSubBitset(combined, layout, i, subMatches[i].ordinalBitset());
       }
       return combined;
     }
@@ -9853,17 +9756,6 @@ function compositeExpandTermPrefix(subs, surfacePrefix, stemmedToken, maxExpansi
 function isCompositePartition(partition) {
   return "attachFrozenSegment" in partition;
 }
-function survivorDocuments(sub, payload) {
-  return payload.docIds.map((docId) => {
-    const stored = sub.docStore.get(docId);
-    if (stored === void 0) {
-      throw new NarsilError(ErrorCodes.PARTITION_CORRUPTED, `Document "${docId}" vanished while composing a segment`, {
-        docId
-      });
-    }
-    return stored.fields;
-  });
-}
 function createCompositePartition(partitionId, trackPositions = true, existingLive) {
   const live = existingLive ?? createPartitionIndex(partitionId, trackPositions);
   const liveState = partitionStateOf(live);
@@ -9886,7 +9778,7 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
     for (const sub of subs()) {
       const payload = encodeSegmentState(sub);
       if (payload.documentCount === 0) continue;
-      scratch.mergeSegmentPayload(payload, survivorDocuments(sub, payload));
+      scratch.mergeSegmentPayload(payload, survivorDocumentsOf(sub, payload));
     }
     return scratch;
   }
@@ -9922,6 +9814,16 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
       swapFrozenSegmentList(frozen, dropSegmentIds, replacement, partitionId);
       invalidateDocFrequencies();
     },
+    freezeLiveTail(freeze) {
+      const segment = freezeLiveTailInto(live, liveState, frozen, freeze);
+      if (segment !== null) invalidateDocFrequencies();
+      return segment;
+    },
+    replaceLiveTail(segment) {
+      live.clear();
+      frozen.push(segment);
+      invalidateDocFrequencies();
+    },
     appendFrozenSegment(payload, documents) {
       for (const docId of payload.docIds) {
         if (live.has(docId) || frozenOwner(docId) !== void 0) {
@@ -9966,7 +9868,7 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
         for (const segment of frozen) {
           const payload = encodeSegmentState(segment);
           if (payload.documentCount === 0) continue;
-          live.mergeSegmentPayload(payload, survivorDocuments(segment, payload));
+          live.mergeSegmentPayload(payload, survivorDocumentsOf(segment, payload));
         }
         frozen.length = 0;
       }
@@ -10231,6 +10133,15 @@ function mergePartitionStats(statsArray) {
   };
 }
 
+// src/search/constants.ts
+var RESULT_WINDOW = 1e4;
+var DEFAULT_PAGE_SIZE = 10;
+var MAX_CURSOR_LENGTH = 40960;
+var MAX_SORT_FIELDS = 8;
+var MAX_SORT_FIELD_NAME_LENGTH = 255;
+var MAX_CURSOR_ANCHOR_CODE_POINTS = 512;
+var PREFIX_MAX_EXPANSIONS = 50;
+
 // src/search/cursor-codec.ts
 function encodeCursorText(text) {
   if (typeof Buffer !== "undefined") return Buffer.from(text, "utf-8").toString("base64");
@@ -10288,11 +10199,6 @@ function applySorting(hits, sort, sortKeyOf) {
 
 // src/search/cursor.ts
 var CURSOR_VERSION = 3;
-var MAX_CURSOR_LENGTH = 40960;
-var MAX_SORT_FIELDS = 8;
-var MAX_SORT_FIELD_NAME_LENGTH = 255;
-var MAX_ANCHOR_CODE_POINTS = 512;
-var MAX_SORT_VALUE_CODE_POINTS = 512;
 function invalidCursor(cursor, reason) {
   const shown = cursor.length > 100 ? `${cursor.slice(0, 100)}...` : cursor;
   return new NarsilError(ErrorCodes.SEARCH_INVALID_CURSOR, `Failed to decode cursor: ${reason}`, { cursor: shown });
@@ -10360,7 +10266,7 @@ function decodeSortKey(value, cursor) {
       continue;
     }
     if (typeof entry === "string") {
-      if (exceedsCodePoints(entry, MAX_SORT_VALUE_CODE_POINTS)) {
+      if (exceedsCodePoints(entry, SORT_VALUE_MAX_CODE_POINTS)) {
         throw invalidCursor(cursor, '"k" holds an oversized sort value');
       }
       key.push(entry);
@@ -10393,7 +10299,7 @@ function decodePageCursor(cursor) {
     throw invalidCursor(cursor, '"q" must be 8 lowercase hex digits');
   }
   if (typeof a !== "string" || a.length === 0) throw invalidCursor(cursor, '"a" must be a non-empty string');
-  if (exceedsCodePoints(a, MAX_ANCHOR_CODE_POINTS)) {
+  if (exceedsCodePoints(a, MAX_CURSOR_ANCHOR_CODE_POINTS)) {
     throw invalidCursor(cursor, '"a" is too long to be a document id');
   }
   if (s !== void 0 && (typeof s !== "number" || !Number.isFinite(s))) {
@@ -10435,8 +10341,6 @@ function requireMatchingCursor(cursor, encoded, signature, scoreAnchored, bindin
 }
 
 // src/search/pagination.ts
-var RESULT_WINDOW = 1e4;
-var DEFAULT_PAGE_SIZE = 10;
 function clampRowCount(value, fallback) {
   if (value === void 0 || !Number.isFinite(value)) return fallback;
   return Math.max(0, Math.floor(value));
@@ -10508,7 +10412,6 @@ function applyPagination(results, limit, offset, binding, cursor, sort, pinnedId
 }
 
 // src/search/fulltext.ts
-var PREFIX_MAX_EXPANSIONS = 50;
 function resolvePrefixExpansion(partition, params, language, options, queryTokens, lastToken) {
   const term = params.term;
   if (term === void 0) return void 0;
@@ -11096,6 +10999,14 @@ function createPartitionManager(indexName, config, language, router, initialPart
         if (docId !== void 0) docPartitionMap.set(docId, partitionId);
       }
     },
+    freezeLiveTail(partitionId, freeze) {
+      validatePartitionId(partitionId);
+      return asCompositePartition(partitionId).freezeLiveTail(freeze);
+    },
+    replaceLiveTail(partitionId, segment) {
+      validatePartitionId(partitionId);
+      asCompositePartition(partitionId).replaceLiveTail(segment);
+    },
     deserializePartition(partitionId, data) {
       validatePartitionId(partitionId);
       partitions[partitionId].deserialize(data, config.schema);
@@ -11160,8 +11071,16 @@ function fanOutMatchCount(manager, params, language, schema, options) {
   return count;
 }
 
+// src/vector/constants.ts
+var WASM_PAGE_BYTES = 65536;
+var MAX_WASM_PAGES = 65536;
+var VECTOR_STORE_INITIAL_CAPACITY = 16;
+var HNSW_BUILD_TIMEOUT_MS = 12e4;
+var VECTOR_SEARCH_TIMEOUT_MS = 3e4;
+var VECTOR_SEARCH_LOAD_TIMEOUT_MS = 3e5;
+var QUANTIZATION_PADDING_FACTOR = 0.01;
+
 // src/vector/scalar-quantization-calibration.ts
-var PADDING_FACTOR = 0.01;
 function computeCalibrationBounds(vectors, dimensions) {
   let globalMin = Number.POSITIVE_INFINITY;
   let globalMax = Number.NEGATIVE_INFINITY;
@@ -11176,7 +11095,7 @@ function computeCalibrationBounds(vectors, dimensions) {
   }
   if (count === 0) return null;
   const range = globalMax - globalMin;
-  const pad = range * PADDING_FACTOR;
+  const pad = range * QUANTIZATION_PADDING_FACTOR;
   globalMin -= pad;
   globalMax += pad;
   if (globalMin === globalMax) {
@@ -11372,8 +11291,6 @@ function arenaFloat32Distance(simd, byteA, byteB, dimension, metric, magnitudeA,
 }
 
 // src/vector/scalar-quantization.ts
-var INITIAL_CAPACITY2 = 16;
-var PAGE_BYTES = 65536;
 function createScalarQuantizer(dimensions, ordinalSource) {
   const docToOrd = /* @__PURE__ */ new Map();
   let simd = createArenaSimd();
@@ -11391,7 +11308,7 @@ function createScalarQuantizer(dimensions, ordinalSource) {
   let calibrated = false;
   function ensureCapacity3(needed) {
     if (needed <= capacity) return;
-    let newCap = capacity === 0 ? INITIAL_CAPACITY2 : capacity;
+    let newCap = capacity === 0 ? VECTOR_STORE_INITIAL_CAPACITY : capacity;
     while (newCap < needed) newCap *= 2;
     const nextSums = new Float64Array(newCap);
     nextSums.set(sums);
@@ -11410,7 +11327,7 @@ function createScalarQuantizer(dimensions, ordinalSource) {
       const have = simd.memory.buffer.byteLength;
       if (requiredBytes > have) {
         try {
-          simd.memory.grow(Math.ceil((requiredBytes - have) / PAGE_BYTES));
+          simd.memory.grow(Math.ceil((requiredBytes - have) / WASM_PAGE_BYTES));
         } catch {
           const migrated = new Uint8Array(newCap * dimensions);
           migrated.set(quantizedArena.subarray(0, capacity * dimensions));
@@ -11721,8 +11638,6 @@ function euclideanDistance(a, b) {
 }
 
 // src/vector/vector-store/index.ts
-var INITIAL_CAPACITY3 = 16;
-var PAGE_BYTES2 = 65536;
 var UNKNOWN_PARTITION = -1;
 var NO_PARTITION = -2;
 function createVectorStore() {
@@ -11749,7 +11664,7 @@ function createVectorStore() {
   }
   function ensureCapacity3(needed) {
     if (needed <= capacity) return;
-    let newCap = capacity === 0 ? INITIAL_CAPACITY3 : capacity;
+    let newCap = capacity === 0 ? VECTOR_STORE_INITIAL_CAPACITY : capacity;
     while (newCap < needed) newCap *= 2;
     const nextMags = new Float64Array(newCap);
     nextMags.set(mags);
@@ -11759,7 +11674,7 @@ function createVectorStore() {
       const have = simd.memory.buffer.byteLength;
       if (requiredBytes > have) {
         try {
-          simd.memory.grow(Math.ceil((requiredBytes - have) / PAGE_BYTES2));
+          simd.memory.grow(Math.ceil((requiredBytes - have) / WASM_PAGE_BYTES));
         } catch {
           const migrated = new Float32Array(newCap * dimension);
           migrated.set(arena.subarray(scratchFloatLength, scratchFloatLength + capacity * dimension));
@@ -11789,7 +11704,7 @@ function createVectorStore() {
   }
   function ensurePartitionSlots(ord) {
     if (ord < partitionOf.length) return;
-    let length = partitionOf.length === 0 ? INITIAL_CAPACITY3 : partitionOf.length;
+    let length = partitionOf.length === 0 ? VECTOR_STORE_INITIAL_CAPACITY : partitionOf.length;
     while (length <= ord) length *= 2;
     const grown = new Int32Array(length).fill(UNKNOWN_PARTITION);
     grown.set(partitionOf);
@@ -12031,10 +11946,193 @@ function createVectorStore() {
   };
 }
 
+// src/vector/hnsw/adjacency.ts
+var ABSENT = -1;
+function createAdjacency(m, mMax0) {
+  return {
+    m,
+    mMax0,
+    level0Stride: mMax0 + 2,
+    upperStride: m + 2,
+    capacity: 0,
+    slots: 0,
+    nodeLevels: new Int8Array(0),
+    level0: new Int32Array(0),
+    upperBase: new Int32Array(0),
+    upper: new Int32Array(0),
+    upperUsed: 0,
+    freeBlocks: Array.from({ length: MAX_LAYER_CAP + 1 }, () => [])
+  };
+}
+function ensureAdjacencyCapacity(adj, needed) {
+  if (needed <= adj.capacity) return;
+  let newCapacity = adj.capacity === 0 ? 16 : adj.capacity;
+  while (newCapacity < needed) newCapacity *= 2;
+  const nextLevels = new Int8Array(newCapacity).fill(ABSENT);
+  nextLevels.set(adj.nodeLevels);
+  adj.nodeLevels = nextLevels;
+  const nextLevel0 = new Int32Array(newCapacity * adj.level0Stride);
+  nextLevel0.set(adj.level0);
+  adj.level0 = nextLevel0;
+  const nextUpperBase = new Int32Array(newCapacity).fill(ABSENT);
+  nextUpperBase.set(adj.upperBase);
+  adj.upperBase = nextUpperBase;
+  adj.capacity = newCapacity;
+}
+function allocateUpperBlock(adj, levels) {
+  const reusable = adj.freeBlocks[levels].pop();
+  const size = levels * adj.upperStride;
+  if (reusable !== void 0) {
+    adj.upper.fill(0, reusable, reusable + size);
+    return reusable;
+  }
+  if (adj.upperUsed + size > adj.upper.length) {
+    const required = adj.upperUsed + size;
+    let nextLength = adj.upper.length === 0 ? INITIAL_UPPER_SLOTS * adj.upperStride : adj.upper.length;
+    while (nextLength < required) nextLength *= 2;
+    const nextUpper = new Int32Array(nextLength);
+    nextUpper.set(adj.upper);
+    adj.upper = nextUpper;
+  }
+  const offset = adj.upperUsed;
+  adj.upperUsed += size;
+  adj.upper.fill(0, offset, offset + size);
+  return offset;
+}
+function createNode(adj, ord, maxLayer) {
+  ensureAdjacencyCapacity(adj, ord + 1);
+  if (ord >= adj.slots) adj.slots = ord + 1;
+  const existingLevel = adj.nodeLevels[ord];
+  const existingBase = adj.upperBase[ord];
+  if (existingLevel >= 1 && existingBase !== ABSENT) {
+    adj.freeBlocks[existingLevel].push(existingBase);
+  }
+  adj.nodeLevels[ord] = maxLayer;
+  adj.level0[ord * adj.level0Stride] = 0;
+  adj.upperBase[ord] = maxLayer >= 1 ? allocateUpperBlock(adj, maxLayer) : ABSENT;
+}
+function deleteNode(adj, ord) {
+  if (ord < 0 || ord >= adj.capacity) return;
+  const level = adj.nodeLevels[ord];
+  const base = adj.upperBase[ord];
+  if (level >= 1 && base !== ABSENT) {
+    adj.freeBlocks[level].push(base);
+  }
+  adj.nodeLevels[ord] = ABSENT;
+  adj.upperBase[ord] = ABSENT;
+  adj.level0[ord * adj.level0Stride] = 0;
+}
+function resetAdjacency(adj) {
+  adj.nodeLevels = new Int8Array(0);
+  adj.level0 = new Int32Array(0);
+  adj.upperBase = new Int32Array(0);
+  adj.upper = new Int32Array(0);
+  adj.upperUsed = 0;
+  adj.capacity = 0;
+  adj.slots = 0;
+  for (const list of adj.freeBlocks) list.length = 0;
+}
+function nodeLevel(adj, ord) {
+  if (ord < 0 || ord >= adj.capacity) return ABSENT;
+  return adj.nodeLevels[ord];
+}
+function hasNode(adj, ord) {
+  return nodeLevel(adj, ord) !== ABSENT;
+}
+function layerArray(adj, layer) {
+  return layer === 0 ? adj.level0 : adj.upper;
+}
+function layerBase(adj, ord, layer) {
+  const level = nodeLevel(adj, ord);
+  if (level === ABSENT || layer > level) return ABSENT;
+  if (layer === 0) return ord * adj.level0Stride;
+  const base = adj.upperBase[ord];
+  if (base === ABSENT) return ABSENT;
+  return base + (layer - 1) * adj.upperStride;
+}
+function neighborCount(adj, ord, layer) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return 0;
+  return layerArray(adj, layer)[base];
+}
+function collectNeighbors(adj, ord, layer) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return [];
+  const array = layerArray(adj, layer);
+  const count = array[base];
+  const collected = new Array(count);
+  for (let i = 0; i < count; i++) {
+    collected[i] = array[base + i + 1];
+  }
+  return collected;
+}
+function addNeighbor(adj, ord, layer, neighborOrd) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return;
+  const array = layerArray(adj, layer);
+  const count = array[base];
+  for (let i = 1; i <= count; i++) {
+    if (array[base + i] === neighborOrd) return;
+  }
+  const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
+  if (count + 1 > stride - 1) return;
+  array[base + count + 1] = neighborOrd;
+  array[base] = count + 1;
+}
+function removeNeighbor(adj, ord, layer, neighborOrd) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return;
+  const array = layerArray(adj, layer);
+  const count = array[base];
+  for (let i = 1; i <= count; i++) {
+    if (array[base + i] !== neighborOrd) continue;
+    for (let j = i; j < count; j++) {
+      array[base + j] = array[base + j + 1];
+    }
+    array[base] = count - 1;
+    return;
+  }
+}
+function replaceNeighbors(adj, ord, layer, neighbors, count) {
+  const base = layerBase(adj, ord, layer);
+  if (base === ABSENT) return;
+  const array = layerArray(adj, layer);
+  const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
+  const limit = Math.min(count, stride - 1);
+  for (let i = 0; i < limit; i++) {
+    array[base + i + 1] = neighbors[i];
+  }
+  array[base] = limit;
+}
+function exportAdjacency(adj) {
+  return {
+    m: adj.m,
+    mMax0: adj.mMax0,
+    capacity: adj.capacity,
+    slots: adj.slots,
+    upperUsed: adj.upperUsed,
+    nodeLevels: adj.nodeLevels.slice(),
+    level0: adj.level0.slice(),
+    upperBase: adj.upperBase.slice(),
+    upper: adj.upper.slice(0, adj.upperUsed)
+  };
+}
+function importAdjacency(snapshot) {
+  const adj = createAdjacency(snapshot.m, snapshot.mMax0);
+  adj.capacity = snapshot.capacity;
+  adj.slots = snapshot.slots;
+  adj.upperUsed = snapshot.upperUsed;
+  adj.nodeLevels = snapshot.nodeLevels;
+  adj.level0 = snapshot.level0;
+  adj.upperBase = snapshot.upperBase;
+  adj.upper = snapshot.upper;
+  return adj;
+}
+function estimateAdjacencyBytes(adj) {
+  return adj.nodeLevels.byteLength + adj.level0.byteLength + adj.upperBase.byteLength + adj.upper.byteLength;
+}
+
 // src/vector/hnsw/shared.ts
-var COMPACTION_TOMBSTONE_RATIO = 0.1;
-var COMPACTION_ABSOLUTE_THRESHOLD = 1e3;
-var SQ8_OVERSELECTION_FACTOR = 2;
 function ensureCapacity(state, needed) {
   ensureAdjacencyCapacity(state.adjacency, needed);
   if (needed <= state.capacity) return;
@@ -12108,7 +12206,6 @@ function addConnection(connections, ord) {
 }
 
 // src/vector/hnsw/workspace.ts
-var INITIAL_LIST_CAPACITY = 64;
 function createList(capacity) {
   return { ords: new Int32Array(capacity), distances: new Float64Array(capacity), size: 0 };
 }
@@ -12699,7 +12796,7 @@ function collectHits(state, query, k, searchMetric, minSimilarity, filter, efSea
 }
 function rerankWithFullPrecision(state, candidates, query, qMag, arenaQuery, k, metric, minSimilarity, filter, hasDocument) {
   const reranked = [];
-  const rerankLimit = Math.max(k * SQ8_OVERSELECTION_FACTOR, 10);
+  const rerankLimit = Math.max(k * SQ8_OVERSELECTION_FACTOR, SQ8_RERANK_FLOOR);
   for (let i = 0; i < candidates.size; i++) {
     const ord = candidates.ords[i];
     if (filter && !ordinalFilterHas(filter, ord)) continue;
@@ -12866,7 +12963,7 @@ function createHNSWIndex(dimension, store, config, quantizer) {
 }
 
 // src/workers/node-worker.browser.ts
-async function spawnNodeWorker(_entryPoint) {
+async function spawnNodeWorker(_entryPoint, _resourceLimits) {
   return null;
 }
 async function isNodeMainThread() {
@@ -12908,7 +13005,6 @@ function detectRuntime() {
 }
 
 // src/vector/hnsw-worker-dispatch.ts
-var BUILD_TIMEOUT_MS = 12e4;
 function resolveWorkerEntryPoint() {
   const base = import.meta.url;
   const distIndex = base.lastIndexOf("/dist/");
@@ -12974,7 +13070,7 @@ async function dispatchWorkerBuild(docIds, vectorData, dimension, config, timeou
       message: "No worker thread support available in the current runtime"
     };
   }
-  const effectiveTimeout = timeoutMs ?? BUILD_TIMEOUT_MS;
+  const effectiveTimeout = timeoutMs ?? HNSW_BUILD_TIMEOUT_MS;
   let transferBuffer;
   if (skipCopy) {
     transferBuffer = vectorData;
@@ -13044,7 +13140,7 @@ async function dispatchWorkerBuild(docIds, vectorData, dimension, config, timeou
   });
 }
 
-// src/vector/vector-index/shared.ts
+// src/vector/vector-index/constants.ts
 var DEFAULT_PROMOTION_THRESHOLD = 1024;
 var DEFAULT_FILTER_THRESHOLD = 0.03;
 var ESTIMATED_MS_PER_TOMBSTONE = 0.05;
@@ -13053,6 +13149,9 @@ var WORKER_BUILD_SIZE_THRESHOLD = 5e3;
 var WORKER_COPY_MIN_VECTORS = 1024;
 var BUILD_CHUNK_SIZE = 100;
 var REBUILD_REMOVED_RATIO = 0.2;
+
+// src/vector/vector-index/shared.ts
+var VECTOR_WORKER_COPIES_ALLOWED = { enabled: true };
 function liveSize(state) {
   return state.store.size - state.tombstones.size;
 }
@@ -13164,6 +13263,16 @@ function recalibrateFromStore(state) {
   sq8.recalibrateAll(storeVectors());
 }
 
+// src/workers/constants.ts
+var WORKER_YOUNG_GENERATION_MB = 24;
+var MIN_WORKER_COUNT = 2;
+var MAX_WORKER_COUNT = 8;
+var FALLBACK_CPU_COUNT = 4;
+var DEFAULT_BACKPRESSURE_LIMIT = 100;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var SHUTDOWN_TIMEOUT_MS = 5e3;
+var CONSECUTIVE_TIMEOUTS_BEFORE_DEATH = 3;
+
 // src/workers/protocol.ts
 function createRequestId() {
   return generateId();
@@ -13190,7 +13299,7 @@ function resolveWorkerCount(requested) {
   if (requested !== void 0 && requested > 0) {
     return requested;
   }
-  let cpuCount = 4;
+  let cpuCount = FALLBACK_CPU_COUNT;
   try {
     if (navigator?.hardwareConcurrency) {
       cpuCount = navigator.hardwareConcurrency;
@@ -13201,9 +13310,13 @@ function resolveWorkerCount(requested) {
       }
     }
   } catch {
-    cpuCount = 4;
+    cpuCount = FALLBACK_CPU_COUNT;
   }
-  return Math.max(2, Math.min(8, cpuCount - 1));
+  return Math.max(MIN_WORKER_COUNT, Math.min(MAX_WORKER_COUNT, cpuCount - 1));
+}
+function splitWorkerBudget(total) {
+  const keyword = Math.ceil(total / 2);
+  return { keyword, vector: total - keyword };
 }
 function createWorkerPool(config) {
   const workerCount = resolveWorkerCount(config.count);
@@ -13212,28 +13325,60 @@ function createWorkerPool(config) {
   const indexAssignment = /* @__PURE__ */ new Map();
   let isShutdown = false;
   function handleWorkerDeath(slotIndex, error) {
-    if (isShutdown || deadSlots.has(slotIndex)) {
+    if (isShutdown) {
       return;
     }
-    deadSlots.add(slotIndex);
     const slot = workers.get(slotIndex);
+    if (slot !== void 0 && !slot.serving) {
+      workers.delete(slotIndex);
+      return;
+    }
+    if (deadSlots.has(slotIndex)) {
+      return;
+    }
+    deadSlots.add(slotIndex);
     const indexNames = slot ? [...slot.indexes].sort() : [];
     workers.delete(slotIndex);
     config.onWorkerCrash?.(slotIndex, indexNames, error);
   }
+  function spawnSlot(slotIndex, serving) {
+    const slot = {
+      executor: config.workerFactory(slotIndex, (error) => handleWorkerDeath(slotIndex, error)),
+      indexes: /* @__PURE__ */ new Set(),
+      inFlight: 0,
+      serving
+    };
+    workers.set(slotIndex, slot);
+    return slot;
+  }
   function ensureWorker(slotIndex) {
-    if (deadSlots.has(slotIndex)) {
-      return void 0;
-    }
-    let slot = workers.get(slotIndex);
-    if (!slot) {
-      slot = {
-        executor: config.workerFactory(slotIndex, (error) => handleWorkerDeath(slotIndex, error)),
-        indexes: /* @__PURE__ */ new Set()
-      };
-      workers.set(slotIndex, slot);
-    }
-    return slot;
+    const slot = workers.get(slotIndex);
+    if (slot !== void 0) return slot;
+    if (deadSlots.has(slotIndex)) return void 0;
+    return spawnSlot(slotIndex, true);
+  }
+  function deadWorkerIds() {
+    return [...deadSlots].filter((slotIndex) => !workers.has(slotIndex)).sort((a, b) => a - b);
+  }
+  function spawnReplacement(slotIndex) {
+    if (isShutdown || !deadSlots.has(slotIndex) || workers.has(slotIndex)) return null;
+    const slot = spawnSlot(slotIndex, false);
+    return {
+      workerId: slotIndex,
+      executor: slot.executor,
+      hold(indexName) {
+        slot.indexes.add(indexName);
+      },
+      admit() {
+        if (workers.get(slotIndex) !== slot) return;
+        deadSlots.delete(slotIndex);
+        slot.serving = true;
+      },
+      abandon() {
+        if (workers.get(slotIndex) === slot) workers.delete(slotIndex);
+        void slot.executor.shutdown().catch(() => void 0);
+      }
+    };
   }
   function assignSlot(indexName) {
     const preferred = fnv1a(indexName) % workerCount;
@@ -13273,11 +13418,11 @@ function createWorkerPool(config) {
       throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Index "${indexName}" is not registered in the worker pool`);
     }
     const slot = workers.get(slotIndex);
-    if (slot) {
+    if (slot?.serving) {
       return slot.executor;
     }
     for (const survivor of workers.values()) {
-      if (survivor.indexes.has(indexName)) {
+      if (survivor.serving && survivor.indexes.has(indexName)) {
         return survivor.executor;
       }
     }
@@ -13322,6 +13467,54 @@ function createWorkerPool(config) {
   function getAllExecutors() {
     return [...workers.values()].map((slot) => slot.executor);
   }
+  function executorsHolding(indexName) {
+    const holders = [];
+    for (const slot of workers.values()) {
+      if (slot.indexes.has(indexName)) holders.push(slot.executor);
+    }
+    return holders;
+  }
+  function lease(workerId, slot) {
+    slot.inFlight += 1;
+    let released = false;
+    return {
+      workerId,
+      executor: slot.executor,
+      release() {
+        if (released) return;
+        released = true;
+        slot.inFlight -= 1;
+      }
+    };
+  }
+  function leaseLeastBusy() {
+    let chosenId = -1;
+    let chosen = null;
+    for (const [workerId, slot] of workers) {
+      if (!slot.serving) continue;
+      if (chosen === null || slot.inFlight < chosen.inFlight) {
+        chosenId = workerId;
+        chosen = slot;
+      }
+      if (chosen.inFlight === 0) break;
+    }
+    return chosen === null ? null : lease(chosenId, chosen);
+  }
+  function queriesInFlight() {
+    let total = 0;
+    for (const slot of workers.values()) {
+      if (slot.serving) total += slot.inFlight;
+    }
+    return total;
+  }
+  function leaseIdle(limit) {
+    const leases = [];
+    for (const [workerId, slot] of workers) {
+      if (leases.length >= limit) break;
+      if (slot.serving && slot.inFlight === 0) leases.push(lease(workerId, slot));
+    }
+    return leases;
+  }
   function addIndexToAll(indexName) {
     if (isShutdown) {
       throw new NarsilError(ErrorCodes.WORKER_CRASHED, "Worker pool has been shut down");
@@ -13331,9 +13524,22 @@ function createWorkerPool(config) {
     }
     indexAssignment.set(indexName, assignSlot(indexName));
   }
+  function spawnAll() {
+    if (isShutdown) {
+      throw new NarsilError(ErrorCodes.WORKER_CRASHED, "Worker pool has been shut down");
+    }
+    for (let i = 0; i < workerCount; i++) ensureWorker(i);
+  }
   return {
     getExecutor,
     getAllExecutors,
+    executorsHolding,
+    leaseLeastBusy,
+    leaseIdle,
+    queriesInFlight,
+    spawnAll,
+    deadWorkerIds,
+    spawnReplacement,
     get workerCount() {
       return workerCount;
     },
@@ -13345,6 +13551,9 @@ function createWorkerPool(config) {
   };
 }
 
+// src/workers/resource-limits.ts
+var WORKER_RESOURCE_LIMITS = { maxYoungGenerationSizeMb: WORKER_YOUNG_GENERATION_MB };
+
 // src/vector/search-pool/spawn.ts
 function resolveWorkerEntryPoint2() {
   const base = import.meta.url;
@@ -13358,7 +13567,7 @@ async function spawnWorker2(entryPoint) {
   const runtime = detectRuntime();
   if (runtime.supportsWorkerThreads) {
     try {
-      return await spawnNodeWorker(new URL(entryPoint));
+      return await spawnNodeWorker(new URL(entryPoint), WORKER_RESOURCE_LIMITS);
     } catch {
       return null;
     }
@@ -13393,8 +13602,6 @@ function listenForFailure(worker, handler) {
 }
 
 // src/vector/search-pool/index.ts
-var SEARCH_TIMEOUT_MS = 3e4;
-var LOAD_TIMEOUT_MS = 3e5;
 async function createVectorSearchPool(requestedCount) {
   const entryPoint = resolveWorkerEntryPoint2();
   const count = resolveWorkerCount(requestedCount);
@@ -13457,7 +13664,7 @@ async function createVectorSearchPool(requestedCount) {
   async function sendSearch(slot, request) {
     slot.outstanding += 1;
     try {
-      return await send(slot, request.requestId, request, SEARCH_TIMEOUT_MS);
+      return await send(slot, request.requestId, request, VECTOR_SEARCH_TIMEOUT_MS);
     } finally {
       slot.outstanding -= 1;
     }
@@ -13474,7 +13681,7 @@ async function createVectorSearchPool(requestedCount) {
         slots.map((slot) => {
           requestCounter += 1;
           const requestId = `${requestCounter}`;
-          return send(slot, requestId, { type: "load", requestId, handle, snapshot }, LOAD_TIMEOUT_MS);
+          return send(slot, requestId, { type: "load", requestId, handle, snapshot }, VECTOR_SEARCH_LOAD_TIMEOUT_MS);
         })
       );
       return outcomes.every(
@@ -13490,7 +13697,7 @@ async function createVectorSearchPool(requestedCount) {
             slot,
             requestId,
             { type: "loadShared", requestId, handle, scratchSlot, snapshot },
-            LOAD_TIMEOUT_MS
+            VECTOR_SEARCH_LOAD_TIMEOUT_MS
           );
         })
       );
@@ -13503,7 +13710,7 @@ async function createVectorSearchPool(requestedCount) {
         slots.map((slot) => {
           requestCounter += 1;
           const requestId = `${requestCounter}`;
-          return send(slot, requestId, { type: "drop", requestId, handle }, SEARCH_TIMEOUT_MS);
+          return send(slot, requestId, { type: "drop", requestId, handle }, VECTOR_SEARCH_TIMEOUT_MS);
         })
       );
     },
@@ -13571,11 +13778,11 @@ async function createVectorSearchPool(requestedCount) {
 var sharedPool = null;
 var poolHolders = 0;
 var workersUnavailable = false;
-function acquireVectorSearchPool() {
+function acquireVectorSearchPool(requestedCount) {
   poolHolders += 1;
   if (workersUnavailable) return Promise.resolve(null);
   if (sharedPool === null) {
-    sharedPool = createVectorSearchPool().then(
+    sharedPool = createVectorSearchPool(requestedCount).then(
       (pool) => {
         if (pool === null) workersUnavailable = true;
         return pool;
@@ -13599,8 +13806,6 @@ async function releaseVectorSearchPool() {
 }
 
 // src/vector/shared-generation/layout.ts
-var WASM_PAGE_BYTES = 65536;
-var MAX_WASM_PAGES = 65536;
 var SCRATCH_ALIGNMENT = 16;
 function alignUp(bytes) {
   return Math.ceil(bytes / SCRATCH_ALIGNMENT) * SCRATCH_ALIGNMENT;
@@ -13742,6 +13947,7 @@ function captureCloneSnapshot(state) {
   };
 }
 function scheduleWorkerCopyLoad(state) {
+  if (!state.workerCopies.enabled) return;
   if (state.disposed || state.workerCopyLoading || state.building) return;
   if (state.workerCopyHandle !== null) return;
   if (!state.hnsw || state.buffer.size > 0) return;
@@ -13753,7 +13959,7 @@ function scheduleWorkerCopyLoad(state) {
 }
 async function loadWorkerCopies(state) {
   const revision = state.revision;
-  const pool = await acquireVectorSearchPool();
+  const pool = await acquireVectorSearchPool(state.workerCopies.count);
   if (pool === null) {
     await releaseVectorSearchPool();
     return;
@@ -14354,7 +14560,7 @@ function searchWithFilter(state, query, k, options, filter) {
 }
 
 // src/vector/vector-index/index.ts
-function createVectorIndex(fieldName, dimension, config) {
+function createVectorIndex(fieldName, dimension, config, workerCopies = VECTOR_WORKER_COPIES_ALLOWED) {
   if (!Number.isInteger(dimension) || dimension <= 0) {
     throw new NarsilError(
       ErrorCodes.VECTOR_DIMENSION_MISMATCH,
@@ -14377,6 +14583,7 @@ function createVectorIndex(fieldName, dimension, config) {
     filterThreshold,
     quantizationMode,
     hnswConfig,
+    workerCopies,
     store,
     tombstones: /* @__PURE__ */ new Set(),
     buffer: /* @__PURE__ */ new Set(),
@@ -14519,8 +14726,15 @@ function createVectorIndex(fieldName, dimension, config) {
 }
 
 // src/workers/direct-executor.ts
-function createDirectExecutor() {
+var NO_VECTOR_WORKER_COPIES = { enabled: false };
+function growPartitionsTo(manager, partitionId) {
+  while (manager.partitionCount <= partitionId) {
+    manager.addPartition();
+  }
+}
+function createDirectExecutor(options) {
   const indexes = /* @__PURE__ */ new Map();
+  const vectorWorkerCopies = options?.vectorWorkerCopies ?? NO_VECTOR_WORKER_COPIES;
   function requireIndex(indexName) {
     const entry = indexes.get(indexName);
     if (!entry) {
@@ -14541,7 +14755,7 @@ function createDirectExecutor() {
     const vectorFields = extractVectorFieldsFromSchema(config.schema);
     const vectorIndexes = /* @__PURE__ */ new Map();
     for (const [fieldPath, dim] of vectorFields) {
-      vectorIndexes.set(fieldPath, createVectorIndex(fieldPath, dim, config.vectorPromotion));
+      vectorIndexes.set(fieldPath, createVectorIndex(fieldPath, dim, config.vectorPromotion, vectorWorkerCopies));
     }
     const manager = createPartitionManager(indexName, config, language, router, partitionCount, vectorIndexes);
     indexes.set(indexName, {
@@ -14598,10 +14812,10 @@ function createDirectExecutor() {
       case "buildSegment": {
         const entry = requireIndex(action.indexName);
         const segment = createPartitionIndex(0, entry.config.trackPositions ?? true);
-        const options = resolvePartitionInsertOptions(entry.config, entry.manager.analysis, action.options);
+        const options2 = resolvePartitionInsertOptions(entry.config, entry.manager.analysis, action.options);
         segment.beginBatch();
         for (const doc of action.documents) {
-          segment.insert(doc.docId, doc.document, entry.config.schema, entry.language, options);
+          segment.insert(doc.docId, doc.document, entry.config.schema, entry.language, options2);
         }
         segment.endBatch();
         return segment.encodeSegment();
@@ -14622,10 +14836,10 @@ function createDirectExecutor() {
       case "attachSegments": {
         const entry = requireIndex(action.indexName);
         for (const segment of action.segments) {
-          while (entry.manager.partitionCount <= segment.partitionId) {
-            entry.manager.addPartition();
-          }
-          entry.manager.attachFrozenSegment(segment.partitionId, createSharedFrozenSegment(segment.snapshot));
+          growPartitionsTo(entry.manager, segment.partitionId);
+          const frozen = createSharedFrozenSegment(segment.snapshot);
+          for (const docId of segment.tombstonedDocIds ?? []) frozen.tombstoneDocument(docId);
+          entry.manager.attachFrozenSegment(segment.partitionId, frozen);
         }
         return void 0;
       }
@@ -14656,6 +14870,19 @@ function createDirectExecutor() {
         partition.swapFrozenSegments(action.dropSegmentIds, createSharedFrozenSegment(action.snapshot));
         return void 0;
       }
+      case "freezeLiveTail": {
+        const entry = requireIndex(action.indexName);
+        growPartitionsTo(entry.manager, action.partitionId);
+        const tail = entry.manager.getPartition(action.partitionId);
+        const held = isCompositePartition(tail) ? tail.live.count() : tail.count();
+        if (held !== action.snapshot.documentCount) {
+          console.warn(
+            `Partition ${action.partitionId} of "${action.indexName}" held ${held} live documents where the frozen tail holds ${action.snapshot.documentCount}`
+          );
+        }
+        entry.manager.replaceLiveTail(action.partitionId, createSharedFrozenSegment(action.snapshot));
+        return void 0;
+      }
       case "remove": {
         const entry = requireIndex(action.indexName);
         entry.manager.remove(action.docId);
@@ -14731,7 +14958,10 @@ function createDirectExecutor() {
         const vectorFields = extractVectorFieldsFromSchema(entry.config.schema);
         const newVectorIndexes = /* @__PURE__ */ new Map();
         for (const [fieldPath, dim] of vectorFields) {
-          newVectorIndexes.set(fieldPath, createVectorIndex(fieldPath, dim, entry.config.vectorPromotion));
+          newVectorIndexes.set(
+            fieldPath,
+            createVectorIndex(fieldPath, dim, entry.config.vectorPromotion, vectorWorkerCopies)
+          );
         }
         entry.manager.resetVectorIndexes(newVectorIndexes);
         entry.vectorIndexes = entry.manager.getVectorIndexes();
@@ -14743,9 +14973,7 @@ function createDirectExecutor() {
       }
       case "deserialize": {
         const entry = requireIndex(action.indexName);
-        while (entry.manager.partitionCount <= action.partitionId) {
-          entry.manager.addPartition();
-        }
+        growPartitionsTo(entry.manager, action.partitionId);
         entry.manager.deserializePartition(action.partitionId, action.data);
         return void 0;
       }
@@ -14777,44 +15005,6 @@ function createDirectExecutor() {
   };
 }
 
-// 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 yieldToEventLoop2() {
   return new Promise((resolve) => {
@@ -14891,7 +15081,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
       throw error;
     }
   }
-  function enqueue2(indexName, entry) {
+  function enqueue(indexName, entry) {
     if (entry.run !== null) {
       return entry.run;
     }
@@ -14905,7 +15095,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;
@@ -14921,7 +15111,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
       });
     }
     if (rebuildMode === "auto") {
-      void enqueue2(indexName, entry).catch(() => void 0);
+      void enqueue(indexName, entry).catch(() => void 0);
     }
   }
   return {
@@ -14955,7 +15145,7 @@ function createAnalysisRebuildCoordinator(config, deps) {
       if (entry === void 0) {
         return Promise.resolve();
       }
-      return enqueue2(indexName, entry);
+      return enqueue(indexName, entry);
     }
   };
 }
@@ -15040,6 +15230,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.browser.ts
 function filesystemUnavailable() {
   throw new NarsilError(
@@ -15360,8 +15559,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;
@@ -15395,8 +15592,8 @@ function yieldToEventLoop3() {
 }
 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 yieldToEventLoop3();
@@ -15988,8 +16185,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;
@@ -16102,7 +16297,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 {
@@ -16122,7 +16317,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`;
@@ -17578,7 +17772,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);
@@ -17996,11 +18193,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;
@@ -18074,7 +18266,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");
@@ -18992,11 +19183,26 @@ function createDurabilityFromTier(tier, wiring) {
   });
 }
 
-// src/engine/index-state/entry.ts
-var DEFAULT_MAX_REOPEN_WAITERS = 64;
-var MAX_REOPEN_FAILURES = 5;
+// src/engine/constants.ts
+var MIN_DOCUMENTS_FOR_SEGMENTS = 64;
+var BATCH_CHUNK_SIZE = 1e3;
+var DEFAULT_LIMIT = DEFAULT_PAGE_SIZE;
+var DEFAULT_OFFSET = 0;
+var INDEX_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var MAX_INDEX_NAME_LENGTH = 255;
+var MAX_DOC_ID_LENGTH = 512;
 var MIN_SWEEP_INTERVAL_MS = 100;
 var MAX_SWEEP_INTERVAL_MS = 6e4;
+var STATISTICS_BROADCAST_INTERVAL_MS = 5e3;
+var FOREIGN_STATS_TTL_MS = 6e4;
+var DEFAULT_SUGGEST_LIMIT = 10;
+var MAX_SUGGEST_LIMIT = 100;
+
+// src/engine/index-state/constants.ts
+var DEFAULT_MAX_REOPEN_WAITERS = 64;
+var MAX_REOPEN_FAILURES = 5;
+
+// src/engine/index-state/entry.ts
 function createLifecycleEntry(state) {
   return {
     state,
@@ -19270,7 +19476,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);
@@ -19373,6 +19582,9 @@ function wireIndexState(wiring) {
         }
       }
     },
+    onAccess(indexName) {
+      wiring.onAccess?.(indexName);
+    },
     canCloseAutomatically(indexName) {
       return !rebalancingIndexes.has(indexName) && !analysisRebuild.isRunning(indexName) && !orchestrator.isIndexBusy(indexName);
     },
@@ -19383,8 +19595,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;
@@ -19538,17 +19748,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 shared2 = shareFrozenSegment(segment);
+    if (shared2 === null) return null;
+    frozen.push(shared2);
+  }
+  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((shared2) => ({
+    partitionId: captured.partitionId,
+    snapshot: shared2.snapshot,
+    tombstonedDocIds: shared2.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,
@@ -19557,22 +19849,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));
@@ -19621,7 +19916,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 = [];
@@ -19635,33 +19930,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 yieldToEventLoop4() {
+  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)) {
@@ -19729,6 +20017,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);
@@ -19741,48 +20036,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 yieldToEventLoop4();
     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) {
@@ -19795,63 +20113,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;
@@ -19878,30 +20234,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()]);
@@ -19909,10 +20287,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;
@@ -19930,7 +20304,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;
@@ -20018,7 +20392,7 @@ function createWorkerExecutor(worker, config) {
       const timeoutId = setTimeout(() => {
         pending.delete(requestId);
         reject2(new NarsilError(ErrorCodes.WORKER_TIMEOUT, "Shutdown timed out"));
-      }, SHUTDOWN_TIMEOUT);
+      }, SHUTDOWN_TIMEOUT_MS);
       pending.set(requestId, {
         resolve: () => resolve(),
         reject: reject2,
@@ -20060,141 +20434,328 @@ 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);
-      await Promise.all(
-        allExecutors.map(
-          (workerExecutor) => workerExecutor.execute({
-            type: "deserialize",
-            indexName: name,
-            partitionId,
-            data: serialized,
-            requestId: `promote-sync-${name}-${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 runPromotion(state, reason) {
+async function replaceWorker(state, pool, workerId) {
+  const replacement = pool.spawnReplacement(workerId);
+  if (replacement === null) return;
   try {
-    const promotable = eligibleIndexNames(state);
-    if (promotable.length === 0) {
-      state.promotionBuffer.length = 0;
-      return;
+    if (state.bootstrapModule !== void 0) {
+      await replacement.executor.execute({
+        type: "bootstrap",
+        moduleUrl: state.bootstrapModule,
+        requestId: createRequestId()
+      });
     }
-    const factory = await createWorkerFactory();
-    const pool = createWorkerPool({
-      count: state.config?.workers?.count,
-      workerFactory: factory,
-      onWorkerCrash(workerId, indexNames, error) {
-        state.callbacks?.onWorkerCrash?.(workerId, indexNames, error);
-      }
-    });
-    for (const name of promotable) {
-      pool.addIndexToAll(name);
-    }
-    await bootstrapWorkers(state, pool, promotable);
-    state.workerPool = pool;
-    for (const name of promotable) {
-      state.promotedIndexes.add(name);
-      state.awaitingBufferedWrites.add(name);
-    }
-    state.promoter.markPromoted();
-    await drainPromotionBuffer(state);
-    state.awaitingBufferedWrites.clear();
-    state.callbacks?.onPromotion?.(pool.workerCount, reason);
+    for (const indexName of [...state.scaledOutIndexes]) {
+      await loadOntoReplacement(state, replacement, indexName);
+    }
+    replacement.admit();
   } catch (err) {
-    state.promotionBuffer.length = 0;
+    replacement.abandon();
     throw err;
-  } finally {
-    state.awaitingBufferedWrites.clear();
-    state.promotionInProgress = false;
   }
 }
-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;
-    return;
+async function replaceDeadWorkers(state, pool) {
+  for (const workerId of pool.deadWorkerIds()) {
+    if (state.workerPool !== pool) return;
+    await replaceWorker(state, pool, workerId);
   }
-  if (state.callbacks?.shouldDeferPromotion?.()) return;
-  const indexMap = collectEligibleIndexes(state);
-  const anticipated = indexMap.get(indexName);
-  if (anticipated === void 0) return;
-  anticipated.documentCount += incomingCount;
-  const result = state.promoter.check(indexMap);
-  if (!result.shouldPromote) return;
-  state.promotionInProgress = true;
-  const run = runPromotion(state, result.reason).catch((err) => {
-    const error = toError3(err);
-    state.promotionBlocked = isDeterministicFailure(error);
-    state.promotionInProgress = false;
-    state.callbacks?.onPromotionFailure?.(result.reason, error, !state.promotionBlocked);
-  });
-  const tracked = run.then(() => {
-    state.promotionRun = null;
+  state.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.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.poolRepair = run;
+  return run;
 }
 
-// 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);
+// 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(
+        pool.getAllExecutors().map(
+          (workerExecutor) => workerExecutor.execute({ type: "bootstrap", moduleUrl, requestId: "copies-bootstrap" })
+        )
+      );
+    }
+  } catch (err) {
+    await pool.shutdown().catch(() => void 0);
+    throw err;
   }
-  return assignments;
+  return pool;
 }
-function mergeWorkerResults(results) {
-  const merged = kWayMerge(results.map((result) => result.scored));
+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;
+      }
+    );
+  }
+  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) {
+    if (dropReason !== void 0) state.droppedCopies.set(indexName, dropReason);
+    throw err;
+  } finally {
+    state.copyLoadBuffers.delete(indexName);
+  }
+  if (reload) state.copyReloadCounts.set(indexName, (state.copyReloadCounts.get(indexName) ?? 0) + 1);
+  scheduleIdleMerge(state, indexName);
+  state.callbacks?.onCopiesLoaded?.(pool.workerCount, reason);
+}
+async function loadAfter(previous, state, indexName, reason) {
+  if (previous !== void 0) await previous.done;
+  if (state.poolRepair !== null) await state.poolRepair;
+  if (!copiesAllowed(state)) return;
+  if (state.scaledOutIndexes.has(indexName) || state.desyncedIndexes.has(indexName)) return;
+  await loadCopies(state, indexName, reason);
+}
+function scaleOutIndex(state, indexName, reason) {
+  const previous = state.copyTransitions.get(indexName);
+  if (previous !== void 0 && previous.kind !== "drop") return previous.done;
+  const kind = state.droppedCopies.has(indexName) ? "reload" : "load";
+  const done = loadAfter(previous, state, indexName, reason).catch((err) => {
+    const error = toError3(err);
+    state.scaleOutBlocked = isDeterministicFailure(error);
+    state.callbacks?.onCopyLoadFailure?.(reason, error, !state.scaleOutBlocked);
+  }).finally(() => {
+    if (state.copyTransitions.get(indexName)?.done === done) state.copyTransitions.delete(indexName);
+  });
+  state.copyTransitions.set(indexName, { kind, done });
+  return done;
+}
+async function scaleOutReadyIndexes(state) {
+  if (!copiesAllowed(state)) return;
+  for (const indexName of state.indexRegistry.keys()) {
+    if (!indexReadyForCopies(state, indexName)) continue;
+    const reason = copyThresholdReason(state, indexName);
+    setTimeout(() => {
+      void scaleOutIndex(state, indexName, reason);
+    }, 0);
+  }
+}
+async function scaleOutBeforeBatch(state, indexName, incomingCount) {
+  if (incomingCount <= 0) return;
+  const pending = state.copyTransitions.get(indexName);
+  if (pending !== void 0) {
+    if (pending.kind === "load") await pending.done;
+    return;
+  }
+  if (!indexReadyForCopies(state, indexName, incomingCount)) return;
+  await scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
+}
+
+// src/engine/orchestration/idle.ts
+function isIndexBusy(state, indexName) {
+  return state.poolRepair !== null || state.copyTransitions.has(indexName) || state.replicationQueues.has(indexName) || state.compactionsInFlight.has(indexName);
+}
+function noteAccess(state, indexName) {
+  state.lastAccessAt.set(indexName, Date.now());
+  if (!copiesAllowed(state)) return;
+  const reloadReason = state.droppedCopies.get(indexName);
+  if (reloadReason !== void 0) {
+    const transition = state.copyTransitions.get(indexName);
+    if (transition !== void 0 && transition.kind !== "drop") return;
+    void scaleOutIndex(state, indexName, reloadReason);
+    return;
+  }
+  if (indexReadyForCopies(state, indexName)) {
+    void scaleOutIndex(state, indexName, copyThresholdReason(state, indexName));
+  }
+}
+async function releaseCopies(state, indexName) {
+  const pool = state.workerPool;
+  if (pool === null) return;
+  await awaitReplicationIdle(state, indexName);
+  const cutoff = Date.now() - state.copyIdleTimeoutMs;
+  if ((state.lastAccessAt.get(indexName) ?? Date.now()) > cutoff) return;
+  if (!state.scaledOutIndexes.has(indexName) || state.compactionsInFlight.has(indexName)) return;
+  state.scaledOutIndexes.delete(indexName);
+  state.droppedCopies.set(indexName, COPY_RELOAD_REASON);
+  cancelIdleMerge(state, indexName);
+  const outcomes = await Promise.allSettled(
+    pool.executorsHolding(indexName).map((worker) => worker.execute({ type: "dropIndex", indexName, requestId: `idle-drop-${indexName}` }))
+  );
+  for (const outcome of outcomes) {
+    if (outcome.status === "rejected") console.warn("Dropping an idle worker copy failed:", outcome.reason);
+  }
+  pool.removeIndex(indexName);
+  state.segmentLedger.delete(indexName);
+}
+async function dropIdleCopies(state, indexName) {
+  const previous = state.copyTransitions.get(indexName);
+  if (previous !== void 0) return;
+  const done = releaseCopies(state, indexName).catch((err) => {
+    console.warn("Dropping idle worker copies failed:", err);
+  }).finally(() => {
+    if (state.copyTransitions.get(indexName)?.done === done) state.copyTransitions.delete(indexName);
+  });
+  state.copyTransitions.set(indexName, { kind: "drop", done });
+  await done;
+}
+async function sweepIdleCopies(state) {
+  const cutoff = Date.now() - state.copyIdleTimeoutMs;
+  for (const indexName of [...state.scaledOutIndexes]) {
+    if ((state.lastAccessAt.get(indexName) ?? Date.now()) > cutoff) continue;
+    if (isIndexBusy(state, indexName)) continue;
+    await dropIdleCopies(state, indexName);
+  }
+}
+function startIdleSweep(state) {
+  if (!state.workersEnabled || state.idleSweep !== null) return;
+  const interval = Math.min(MAX_SWEEP_INTERVAL_MS, Math.max(MIN_SWEEP_INTERVAL_MS, state.copyIdleTimeoutMs / 2));
+  const timer = setInterval(() => void sweepIdleCopies(state).catch(() => void 0), interval);
+  if (typeof timer.unref === "function") timer.unref();
+  state.idleSweep = timer;
+}
+function stopIdleSweep(state) {
+  if (state.idleSweep === null) return;
+  clearInterval(state.idleSweep);
+  state.idleSweep = null;
+}
+
+// src/engine/orchestration/search.ts
+function 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;
+}
+function mergeWorkerResults(results) {
+  const merged = kWayMerge(results.map((result) => result.scored));
   let totalMatched = 0;
   const workerFacets = [];
   for (const result of results) {
@@ -20207,67 +20768,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) {
@@ -20284,44 +20854,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 [];
@@ -20333,93 +20914,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());
@@ -20461,10 +21171,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) {
@@ -20483,11 +21196,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 });
@@ -20496,10 +21209,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 });
@@ -20688,7 +21401,8 @@ function createEngineCore(config, hooks) {
     rebalancingIndexes,
     requireManager,
     onClose: hooks?.onIndexClose,
-    onOpen: hooks?.onIndexOpen
+    onOpen: hooks?.onIndexOpen,
+    onAccess: (indexName) => orchestrator.noteAccess(indexName)
   });
   const mutationCtx = {
     executor,
@@ -20722,7 +21436,6 @@ function createEngineCore(config, hooks) {
   };
   return {
     executor,
-    promoter,
     pluginRegistry,
     durability,
     invalidation,
@@ -20748,97 +21461,6 @@ function createEngineCore(config, hooks) {
     rebalanceCtx
   };
 }
-var MAX_INDEX_NAME_LENGTH = 255;
-
-// 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) {
@@ -21450,7 +22072,7 @@ async function insertDocument(ctx, indexName, document, docId, options) {
     }
   }
   ctx.checkWatermark(indexName);
-  await ctx.orchestrator.checkPromotion();
+  await ctx.orchestrator.scaleOutReadyIndexes();
   return resolvedDocId;
 }
 
@@ -21604,7 +22226,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)));
@@ -21864,7 +22485,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 };
 }
 
@@ -21872,7 +22493,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);
   }
@@ -22026,7 +22647,7 @@ async function insertDocumentBatch(ctx, indexName, documents, options) {
     }
   }
   ctx.checkWatermark(indexName);
-  await ctx.orchestrator.checkPromotion();
+  await ctx.orchestrator.scaleOutReadyIndexes();
   return { succeeded, failed };
 }
 
@@ -22301,7 +22922,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;
@@ -22734,8 +23355,8 @@ async function createSnapshot(manager, entry) {
   }
   const config = entry.config;
   const bm25 = config.bm25;
-  const { encode: encode14 } = await import('@msgpack/msgpack');
-  const payload = encode14({
+  const { encode: encode13 } = await import('@msgpack/msgpack');
+  const payload = encode13({
     version: 2,
     schema: config.schema,
     language: entry.language.name,
@@ -22772,10 +23393,10 @@ async function restoreFromSnapshot(indexName, data, deps) {
     throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Snapshot data must be a Uint8Array");
   }
   const payloadBytes = hasNrslMagic(data) ? await unpackIndexSnapshotEnvelope(data) : data;
-  const { decode: decode14 } = await import('@msgpack/msgpack');
+  const { decode: decode13 } = await import('@msgpack/msgpack');
   let decoded;
   try {
-    decoded = decode14(payloadBytes);
+    decoded = decode13(payloadBytes);
   } catch (err) {
     throw new NarsilError(
       ErrorCodes.DOC_VALIDATION_FAILED,
@@ -24136,8 +24757,6 @@ async function resolveVectorText(params, embeddingAdapter, signal, embeddingAdap
 }
 
 // src/engine/suggest.ts
-var DEFAULT_SUGGEST_LIMIT = 10;
-var MAX_SUGGEST_LIMIT = 100;
 function executeSuggest(manager, language, params, partitionIds) {
   const t0 = performance.now();
   const ceiling = MAX_SUGGEST_LIMIT ;
@@ -24210,7 +24829,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,
@@ -24250,7 +24869,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,
@@ -24541,6 +25160,7 @@ function createNarsilFromCore(core, config) {
         openIndexCount: lifecycleCounts.open,
         closedIndexCount: lifecycleCounts.closed,
         reopenCount: lifecycleCounts.reopens,
+        workerCopies: orchestrator.workerCopies(),
         workers
       };
     },