@delali/narsil 0.1.7 → 0.1.8

package/dist/index.mjs

@@ -1,3236 +1,7 @@
-import { createDirectExecutor, createPartitionRouter, validateSchema, getLanguage, deserializePayloadV2, extractVectorFieldsFromSchema, tokenize, fanOutQuery, validateRequiredFields, flattenSchema, getNestedValue, detectRuntime, fnv1a, kWayMerge, createPartitionIndex } from './chunk-KHL4RPC3.mjs';
-export { clearNormalizationCache, configureNormalizationCache, getLanguage, getNormalizationCacheSize, registerLanguage, resetNormalizationCache } from './chunk-KHL4RPC3.mjs';
-export { isSimdAvailable } from './chunk-VVORJOXR.mjs';
-import './chunk-I24SGLFS.mjs';
-import { ErrorCodes, NarsilError } from './chunk-R2C2EQGO.mjs';
-export { ErrorCodes, NarsilError } from './chunk-R2C2EQGO.mjs';
-import { generateId, isValidWorkerResponse, createRequestId } from './chunk-HRABJLPB.mjs';
-import { decode } from '@msgpack/msgpack';
-
-// src/engine/embed.ts
-function validateVector(vector, targetField, expectedDimensions) {
-  if (!(vector instanceof Float32Array)) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_FAILED,
-      `Adapter returned ${typeof vector} for field "${targetField}", expected Float32Array`,
-      { field: targetField, returnedType: typeof vector }
-    );
-  }
-  if (vector.length !== expectedDimensions) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_DIMENSION_MISMATCH,
-      `Adapter returned ${vector.length}-dimensional vector for field "${targetField}", expected ${expectedDimensions}`,
-      { field: targetField, expected: expectedDimensions, actual: vector.length }
-    );
-  }
-  for (let i = 0; i < vector.length; i++) {
-    if (Number.isNaN(vector[i])) {
-      throw new NarsilError(
-        ErrorCodes.EMBEDDING_FAILED,
-        `Adapter returned vector with NaN at index ${i} for field "${targetField}"`,
-        { field: targetField, index: i }
-      );
-    }
-  }
-  return vector;
-}
-function resolveFieldValue(document, path) {
-  if (!path.includes(".")) return document[path];
-  const segments = path.split(".");
-  let current = document;
-  for (const segment of segments) {
-    if (current === null || current === void 0 || typeof current !== "object") return void 0;
-    current = current[segment];
-  }
-  return current;
-}
-function setFieldValue(document, path, value) {
-  if (!path.includes(".")) {
-    document[path] = value;
-    return;
-  }
-  const segments = path.split(".");
-  let current = document;
-  for (let i = 0; i < segments.length - 1; i++) {
-    let next = current[segments[i]];
-    if (next === null || next === void 0 || typeof next !== "object") {
-      next = {};
-      current[segments[i]] = next;
-    }
-    current = next;
-  }
-  current[segments[segments.length - 1]] = value;
-}
-function deleteFieldValue(document, path) {
-  if (!path.includes(".")) {
-    delete document[path];
-    return;
-  }
-  const segments = path.split(".");
-  let current = document;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const next = current[segments[i]];
-    if (next === null || next === void 0 || typeof next !== "object") return;
-    current = next;
-  }
-  delete current[segments[segments.length - 1]];
-}
-function collectSourceText(document, sourceFields, targetField, documentIndex) {
-  const sources = Array.isArray(sourceFields) ? sourceFields : [sourceFields];
-  const parts = [];
-  for (const source of sources) {
-    const value = resolveFieldValue(document, source);
-    if (value === void 0 || value === null || value === "") continue;
-    if (typeof value !== "string") {
-      throw new NarsilError(
-        ErrorCodes.DOC_VALIDATION_FAILED,
-        `Embedding source field "${source}" must be a string, got ${typeof value}`,
-        { field: source, targetField }
-      );
-    }
-    parts.push(value);
-  }
-  if (parts.length === 0) {
-    const details = { field: targetField };
-    if (documentIndex !== void 0) {
-      details.documentIndex = documentIndex;
-    }
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_NO_SOURCE,
-      `All source fields for embedding target "${targetField}" are missing or empty`,
-      details
-    );
-  }
-  return parts.join("\n");
-}
-function wrapAdapterError(err, targetField) {
-  if (err instanceof NarsilError) return err;
-  const message = err instanceof Error ? err.message : String(err);
-  return new NarsilError(ErrorCodes.EMBEDDING_FAILED, `Embedding failed for field "${targetField}": ${message}`, {
-    field: targetField,
-    cause: message
-  });
-}
-async function embedDocumentFields(document, embeddingConfig, adapter, signal) {
-  const embeddedFields = /* @__PURE__ */ new Set();
-  try {
-    for (const [targetField, sourceFields] of Object.entries(embeddingConfig.fields)) {
-      const existing = resolveFieldValue(document, targetField);
-      if (existing !== void 0 && existing !== null) continue;
-      const text = collectSourceText(document, sourceFields, targetField);
-      let vector;
-      try {
-        const raw = await adapter.embed(text, "document", signal);
-        vector = validateVector(raw, targetField, adapter.dimensions);
-      } catch (err) {
-        throw wrapAdapterError(err, targetField);
-      }
-      setFieldValue(document, targetField, vector);
-      embeddedFields.add(targetField);
-    }
-  } catch (err) {
-    for (const field of embeddedFields) {
-      deleteFieldValue(document, field);
-    }
-    throw err;
-  }
-  return embeddedFields;
-}
-var SOURCE_FAILURE_CODES = /* @__PURE__ */ new Set([ErrorCodes.EMBEDDING_NO_SOURCE, ErrorCodes.DOC_VALIDATION_FAILED]);
-function isDocumentSourceError(err) {
-  return err instanceof NarsilError && SOURCE_FAILURE_CODES.has(err.code);
-}
-async function embedBatchDocumentFields(documents, embeddingConfig, adapter, signal) {
-  const embedded = /* @__PURE__ */ new Map();
-  const failed = /* @__PURE__ */ new Map();
-  try {
-    for (const [targetField, sourceFields] of Object.entries(embeddingConfig.fields)) {
-      const needsEmbedding = [];
-      for (let i = 0; i < documents.length; i++) {
-        if (failed.has(i)) continue;
-        const doc = documents[i];
-        const existing = resolveFieldValue(doc, targetField);
-        if (existing !== void 0 && existing !== null) continue;
-        try {
-          const text = collectSourceText(doc, sourceFields, targetField, i);
-          needsEmbedding.push({ docIndex: i, text });
-        } catch (err) {
-          if (isDocumentSourceError(err)) {
-            failed.set(i, err);
-          } else {
-            throw err;
-          }
-        }
-      }
-      if (needsEmbedding.length === 0) continue;
-      const texts = needsEmbedding.map((entry) => entry.text);
-      let vectors;
-      try {
-        if (adapter.embedBatch) {
-          vectors = await adapter.embedBatch(texts, "document", signal);
-        } else {
-          vectors = [];
-          const concurrency = 8;
-          for (let start = 0; start < texts.length; start += concurrency) {
-            const chunk = texts.slice(start, start + concurrency);
-            const chunkResults = await Promise.all(chunk.map((t) => adapter.embed(t, "document", signal)));
-            vectors.push(...chunkResults);
-          }
-        }
-      } catch (err) {
-        throw wrapAdapterError(err, targetField);
-      }
-      if (vectors.length !== needsEmbedding.length) {
-        throw new NarsilError(
-          ErrorCodes.EMBEDDING_FAILED,
-          `Adapter returned ${vectors.length} vectors for ${needsEmbedding.length} inputs on field "${targetField}"`,
-          { field: targetField, expected: needsEmbedding.length, actual: vectors.length }
-        );
-      }
-      for (let j = 0; j < needsEmbedding.length; j++) {
-        const { docIndex } = needsEmbedding[j];
-        const validated = validateVector(vectors[j], targetField, adapter.dimensions);
-        setFieldValue(documents[docIndex], targetField, validated);
-        let fieldSet = embedded.get(docIndex);
-        if (!fieldSet) {
-          fieldSet = /* @__PURE__ */ new Set();
-          embedded.set(docIndex, fieldSet);
-        }
-        fieldSet.add(targetField);
-      }
-    }
-  } catch (err) {
-    for (const [docIndex, fields] of embedded) {
-      for (const field of fields) {
-        deleteFieldValue(documents[docIndex], field);
-      }
-    }
-    throw err;
-  }
-  return { embedded, failed };
-}
-
-// src/engine/validation.ts
-var INDEX_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-var MAX_INDEX_NAME_LENGTH = 256;
-var MAX_DOC_ID_LENGTH = 512;
-var BATCH_CHUNK_SIZE = 1e3;
-var MAX_LIMIT = 1e4;
-var MAX_OFFSET = 1e5;
-var DEFAULT_LIMIT = 10;
-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 clampLimit(limit) {
-  if (limit === void 0) return DEFAULT_LIMIT;
-  return Math.max(0, Math.min(limit, MAX_LIMIT));
-}
-function clampOffset(offset) {
-  if (offset === void 0) return DEFAULT_OFFSET;
-  return Math.max(0, Math.min(offset, MAX_OFFSET));
-}
-
-// src/engine/vector-coordinator.ts
-function extractVectorFromDoc(document, fieldPath) {
-  const value = getNestedValue(document, fieldPath);
-  if (value === void 0 || value === null) return null;
-  if (value instanceof Float32Array) return value;
-  if (!Array.isArray(value)) return null;
-  const arr = new Float32Array(value.length);
-  for (let i = 0; i < value.length; i++) {
-    const n = value[i];
-    if (typeof n !== "number" || !Number.isFinite(n)) return null;
-    arr[i] = n;
-  }
-  return arr;
-}
-function deleteNestedValue(obj, path) {
-  if (!path.includes(".")) {
-    delete obj[path];
-    return;
-  }
-  const segments = path.split(".");
-  let current = obj;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const next = current[segments[i]];
-    if (next === null || next === void 0 || typeof next !== "object") return;
-    current = next;
-  }
-  delete current[segments[segments.length - 1]];
-}
-function vectorsEqual(a, b) {
-  if (!a) return false;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
-function validateVectorDimensions(vectors, vecIndexes) {
-  for (const [fieldPath, vector] of vectors) {
-    const vecIndex = vecIndexes.get(fieldPath);
-    if (!vecIndex) continue;
-    if (vector.length !== vecIndex.dimension) {
-      throw new NarsilError(
-        ErrorCodes.VECTOR_DIMENSION_MISMATCH,
-        `Vector dimension mismatch for field "${fieldPath}": expected ${vecIndex.dimension}, got ${vector.length}`,
-        { field: fieldPath, expected: vecIndex.dimension, received: vector.length }
-      );
-    }
-  }
-}
-function prepareDocumentVectors(document, vectorFieldPaths, vecIndexes) {
-  if (vecIndexes.size === 0) {
-    return { partitionDoc: document, extractedVectors: /* @__PURE__ */ new Map() };
-  }
-  const extractedVectors = /* @__PURE__ */ new Map();
-  for (const fieldPath of vectorFieldPaths) {
-    const vec = extractVectorFromDoc(document, fieldPath);
-    if (vec) {
-      extractedVectors.set(fieldPath, vec);
-    }
-  }
-  if (extractedVectors.size === 0) {
-    return { partitionDoc: document, extractedVectors };
-  }
-  const partitionDoc = shallowCopyExcluding(document, extractedVectors.keys());
-  return { partitionDoc, extractedVectors };
-}
-function shallowCopyExcluding(document, fieldPaths) {
-  const topLevelExcludes = /* @__PURE__ */ new Set();
-  const nestedPaths = [];
-  for (const path of fieldPaths) {
-    if (!path.includes(".")) {
-      topLevelExcludes.add(path);
-    } else {
-      nestedPaths.push(path);
-    }
-  }
-  const result = {};
-  for (const key of Object.keys(document)) {
-    if (topLevelExcludes.has(key)) continue;
-    result[key] = document[key];
-  }
-  for (const path of nestedPaths) {
-    const segments = path.split(".");
-    const topKey = segments[0];
-    if (!(topKey in result) || result[topKey] === null || typeof result[topKey] !== "object") continue;
-    const source = document[topKey];
-    let target = { ...source };
-    result[topKey] = target;
-    for (let i = 1; i < segments.length - 1; i++) {
-      const seg = segments[i];
-      const next = target[seg];
-      if (next === null || next === void 0 || typeof next !== "object") break;
-      const copy = { ...next };
-      target[seg] = copy;
-      target = copy;
-    }
-    delete target[segments[segments.length - 1]];
-  }
-  return result;
-}
-function insertDocumentVectors(docId, vectors, vecIndexes) {
-  const insertedFields = [];
-  try {
-    for (const [fieldPath, vector] of vectors) {
-      const vecIndex = vecIndexes.get(fieldPath);
-      if (!vecIndex) continue;
-      vecIndex.insert(docId, vector);
-      insertedFields.push(fieldPath);
-    }
-  } catch (err) {
-    for (const fieldPath of insertedFields) {
-      const vecIndex = vecIndexes.get(fieldPath);
-      if (vecIndex) {
-        vecIndex.remove(docId);
-      }
-    }
-    throw err;
-  }
-  return insertedFields;
-}
-function removeDocumentVectors(docId, vecIndexes) {
-  for (const [, vecIndex] of vecIndexes) {
-    vecIndex.remove(docId);
-  }
-}
-function updateDocumentVectors(docId, vectors, vecIndexes) {
-  const updatedFields = [];
-  try {
-    for (const [fieldPath, newVec] of vectors) {
-      const vecIndex = vecIndexes.get(fieldPath);
-      if (!vecIndex) continue;
-      if (newVec === null) {
-        if (vecIndex.has(docId)) {
-          const oldVec2 = vecIndex.getVector(docId);
-          vecIndex.remove(docId);
-          updatedFields.push({ fieldPath, oldVec: oldVec2 });
-        }
-        continue;
-      }
-      const oldVec = vecIndex.getVector(docId);
-      if (vectorsEqual(oldVec, newVec)) continue;
-      vecIndex.remove(docId);
-      try {
-        vecIndex.insert(docId, newVec);
-        updatedFields.push({ fieldPath, oldVec });
-      } catch (err) {
-        if (oldVec) {
-          vecIndex.insert(docId, oldVec);
-        }
-        throw err;
-      }
-    }
-  } catch (err) {
-    for (const { fieldPath, oldVec } of updatedFields) {
-      const vecIndex = vecIndexes.get(fieldPath);
-      if (!vecIndex) continue;
-      vecIndex.remove(docId);
-      if (oldVec) {
-        vecIndex.insert(docId, oldVec);
-      }
-    }
-    throw err;
-  }
-}
-
-// src/engine/mutations.ts
-async function insertDocument(ctx, indexName, document, docId, options) {
-  ctx.guardShutdown();
-  const entry = ctx.requireIndex(indexName);
-  const resolvedDocId = docId ?? ctx.idGenerator();
-  validateDocId(resolvedDocId);
-  if (ctx.bufferIfRebalancing(indexName, { action: "insert", docId: resolvedDocId, document, indexName })) {
-    return resolvedDocId;
-  }
-  await ctx.pluginRegistry.runHook("beforeInsert", { indexName, docId: resolvedDocId, document });
-  if (entry.config.required && entry.config.required.length > 0) {
-    validateRequiredFields(document, entry.config.required);
-  }
-  if (entry.embeddingAdapter && entry.config.embedding) {
-    await embedDocumentFields(
-      document,
-      entry.config.embedding,
-      entry.embeddingAdapter,
-      ctx.abortController.signal
-    );
-  }
-  const insertManager = ctx.requireManager(indexName);
-  const insertVecIndexes = insertManager.getVectorIndexes();
-  const { partitionDoc, extractedVectors } = prepareDocumentVectors(
-    document,
-    entry.vectorFieldPaths,
-    insertVecIndexes
-  );
-  if (extractedVectors.size > 0) {
-    validateVectorDimensions(extractedVectors, insertVecIndexes);
-  }
-  await ctx.executor.execute({
-    type: "insert",
-    indexName,
-    docId: resolvedDocId,
-    document: partitionDoc,
-    requestId: resolvedDocId,
-    skipClone: extractedVectors.size > 0 ? true : options?.skipClone
-  });
-  try {
-    insertDocumentVectors(resolvedDocId, extractedVectors, insertVecIndexes);
-  } catch (err) {
-    try {
-      await ctx.executor.execute({ type: "remove", indexName, docId: resolvedDocId, requestId: resolvedDocId });
-    } catch (rollbackErr) {
-      console.warn(
-        `Rollback failed for doc "${resolvedDocId}" during insert atomicity:`,
-        rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)
-      );
-    }
-    throw err;
-  }
-  try {
-    await ctx.pluginRegistry.runHook("afterInsert", { indexName, docId: resolvedDocId, document });
-  } catch (err) {
-    console.warn("afterInsert plugin hook error:", err instanceof Error ? err.message : String(err));
-  }
-  ctx.flushManager?.markDirty(indexName, 0);
-  await ctx.orchestrator.replicateToWorkers({
-    type: "insert",
-    indexName,
-    docId: resolvedDocId,
-    document,
-    requestId: `replicate-insert-${resolvedDocId}`,
-    skipClone: options?.skipClone
-  });
-  for (const fieldPath of extractedVectors.keys()) {
-    const vecIndex = insertVecIndexes.get(fieldPath);
-    if (vecIndex) {
-      vecIndex.scheduleBuild();
-    }
-  }
-  await ctx.orchestrator.checkPromotion();
-  return resolvedDocId;
-}
-async function insertDocumentBatch(ctx, indexName, documents, options) {
-  ctx.guardShutdown();
-  const entry = ctx.requireIndex(indexName);
-  const succeeded = [];
-  const succeededDocs = [];
-  const failed = [];
-  const hasBeforeHook = ctx.pluginRegistry.hasHooks("beforeInsert");
-  const hasAfterHook = ctx.pluginRegistry.hasHooks("afterInsert");
-  const hasRequired = entry.config.required && entry.config.required.length > 0;
-  const hasEmbedding = entry.embeddingAdapter && entry.config.embedding;
-  const batchManager = ctx.requireManager(indexName);
-  const batchVecIndexes = batchManager.getVectorIndexes();
-  const batchVectorFieldPaths = batchVecIndexes.size > 0 ? entry.vectorFieldPaths : /* @__PURE__ */ new Set();
-  const touchedVectorFields = /* @__PURE__ */ new Set();
-  for (let chunkStart = 0; chunkStart < documents.length; chunkStart += BATCH_CHUNK_SIZE) {
-    if (ctx.abortController.signal.aborted) break;
-    const chunkEnd = Math.min(chunkStart + BATCH_CHUNK_SIZE, documents.length);
-    const chunkFailedIndexes = /* @__PURE__ */ new Set();
-    if (hasRequired) {
-      for (let i = chunkStart; i < chunkEnd; i++) {
-        try {
-          validateRequiredFields(documents[i], entry.config.required);
-        } catch (err) {
-          chunkFailedIndexes.add(i);
-          failed.push({
-            docId: "",
-            error: err instanceof NarsilError ? err : new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, String(err))
-          });
-        }
-      }
-    }
-    if (hasEmbedding) {
-      const embeddableSlice = [];
-      const embeddableOriginalIndexes = [];
-      for (let i = chunkStart; i < chunkEnd; i++) {
-        if (chunkFailedIndexes.has(i)) continue;
-        embeddableSlice.push(documents[i]);
-        embeddableOriginalIndexes.push(i);
-      }
-      if (embeddableSlice.length > 0) {
-        try {
-          const embedResult = await embedBatchDocumentFields(
-            embeddableSlice,
-            entry.config.embedding,
-            entry.embeddingAdapter,
-            ctx.abortController.signal
-          );
-          for (const [sliceIndex, error] of embedResult.failed) {
-            const originalIdx = embeddableOriginalIndexes[sliceIndex];
-            chunkFailedIndexes.add(originalIdx);
-            failed.push({ docId: "", error });
-          }
-        } catch (err) {
-          const embeddingError = err instanceof NarsilError ? err : new NarsilError(ErrorCodes.EMBEDDING_FAILED, String(err));
-          for (const originalIdx of embeddableOriginalIndexes) {
-            chunkFailedIndexes.add(originalIdx);
-            failed.push({ docId: "", error: embeddingError });
-          }
-        }
-      }
-    }
-    for (let i = chunkStart; i < chunkEnd; i++) {
-      if (ctx.abortController.signal.aborted) break;
-      if (chunkFailedIndexes.has(i)) continue;
-      const batchDocId = ctx.idGenerator();
-      try {
-        validateDocId(batchDocId);
-        if (hasBeforeHook) {
-          await ctx.pluginRegistry.runHook("beforeInsert", { indexName, docId: batchDocId, document: documents[i] });
-        }
-        const { partitionDoc, extractedVectors } = prepareDocumentVectors(
-          documents[i],
-          batchVectorFieldPaths,
-          batchVecIndexes
-        );
-        if (extractedVectors.size > 0) {
-          validateVectorDimensions(extractedVectors, batchVecIndexes);
-        }
-        const result = ctx.executor.execute({
-          type: "insert",
-          indexName,
-          docId: batchDocId,
-          document: partitionDoc,
-          requestId: batchDocId,
-          skipClone: extractedVectors.size > 0 ? true : options?.skipClone
-        });
-        if (result && typeof result.then === "function") {
-          await result;
-        }
-        try {
-          insertDocumentVectors(batchDocId, extractedVectors, batchVecIndexes);
-        } catch (vecErr) {
-          try {
-            await ctx.executor.execute({ type: "remove", indexName, docId: batchDocId, requestId: batchDocId });
-          } catch (rollbackErr) {
-            console.warn(
-              `Rollback failed for doc "${batchDocId}" during batch insert atomicity:`,
-              rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)
-            );
-          }
-          throw vecErr;
-        }
-        for (const fieldPath of extractedVectors.keys()) {
-          touchedVectorFields.add(fieldPath);
-        }
-        if (hasAfterHook) {
-          try {
-            await ctx.pluginRegistry.runHook("afterInsert", { indexName, docId: batchDocId, document: documents[i] });
-          } catch (err) {
-            console.warn("afterInsert plugin hook error:", err instanceof Error ? err.message : String(err));
-          }
-        }
-        succeeded.push(batchDocId);
-        succeededDocs.push(documents[i]);
-      } catch (err) {
-        failed.push({
-          docId: batchDocId,
-          error: err instanceof NarsilError ? err : new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, String(err))
-        });
-      }
-    }
-    if (chunkEnd < documents.length) {
-      await new Promise((r) => setTimeout(r, 0));
-    }
-  }
-  ctx.flushManager?.markDirty(indexName, 0);
-  for (let i = 0; i < succeeded.length; i++) {
-    await ctx.orchestrator.replicateToWorkers({
-      type: "insert",
-      indexName,
-      docId: succeeded[i],
-      document: succeededDocs[i],
-      requestId: `replicate-insert-${succeeded[i]}`,
-      skipClone: options?.skipClone
-    });
-  }
-  for (const fieldPath of touchedVectorFields) {
-    const vecIndex = batchVecIndexes.get(fieldPath);
-    if (vecIndex) {
-      vecIndex.scheduleBuild();
-    }
-  }
-  await ctx.orchestrator.checkPromotion();
-  return { succeeded, failed };
-}
-async function removeDocument(ctx, indexName, docId) {
-  ctx.guardShutdown();
-  ctx.requireIndex(indexName);
-  validateDocId(docId);
-  if (ctx.bufferIfRebalancing(indexName, { action: "remove", docId, indexName })) {
-    return;
-  }
-  await ctx.pluginRegistry.runHook("beforeRemove", { indexName, docId });
-  await ctx.executor.execute({ type: "remove", indexName, docId, requestId: docId });
-  const removeManager = ctx.requireManager(indexName);
-  const removeVecIndexes = removeManager.getVectorIndexes();
-  removeDocumentVectors(docId, removeVecIndexes);
-  try {
-    await ctx.pluginRegistry.runHook("afterRemove", { indexName, docId });
-  } catch (err) {
-    console.warn("afterRemove plugin hook error:", err instanceof Error ? err.message : String(err));
-  }
-  ctx.flushManager?.markDirty(indexName, 0);
-  await ctx.orchestrator.replicateToWorkers({
-    type: "remove",
-    indexName,
-    docId,
-    requestId: `replicate-remove-${docId}`
-  });
-}
-async function removeDocumentBatch(ctx, indexName, docIds) {
-  ctx.guardShutdown();
-  ctx.requireIndex(indexName);
-  const succeeded = [];
-  const failed = [];
-  const manager = ctx.requireManager(indexName);
-  manager.beginBatchRemove();
-  try {
-    for (let chunkStart = 0; chunkStart < docIds.length; chunkStart += BATCH_CHUNK_SIZE) {
-      const chunkEnd = Math.min(chunkStart + BATCH_CHUNK_SIZE, docIds.length);
-      for (let i = chunkStart; i < chunkEnd; i++) {
-        try {
-          await removeDocument(ctx, indexName, docIds[i]);
-          succeeded.push(docIds[i]);
-        } catch (err) {
-          failed.push({
-            docId: docIds[i],
-            error: err instanceof NarsilError ? err : new NarsilError(ErrorCodes.DOC_NOT_FOUND, String(err))
-          });
-        }
-      }
-      if (chunkEnd < docIds.length) {
-        await new Promise((r) => setTimeout(r, 0));
-      }
-    }
-  } finally {
-    manager.endBatchRemove();
-  }
-  return { succeeded, failed };
-}
-async function updateDocument(ctx, indexName, docId, document) {
-  ctx.guardShutdown();
-  const entry = ctx.requireIndex(indexName);
-  validateDocId(docId);
-  if (ctx.bufferIfRebalancing(indexName, { action: "update", docId, document, indexName })) {
-    return;
-  }
-  if (entry.embeddingAdapter && entry.config.embedding) {
-    await embedDocumentFields(
-      document,
-      entry.config.embedding,
-      entry.embeddingAdapter,
-      ctx.abortController.signal
-    );
-  }
-  const updateManager = ctx.requireManager(indexName);
-  const oldDocument = updateManager.get(docId);
-  const oldPartitionDoc = updateManager.getRef(docId);
-  const rollbackDoc = oldPartitionDoc ? structuredClone(oldPartitionDoc) : void 0;
-  await ctx.pluginRegistry.runHook("beforeUpdate", {
-    indexName,
-    docId,
-    oldDocument: oldDocument ?? {},
-    newDocument: document
-  });
-  const updateVecIndexes = updateManager.getVectorIndexes();
-  const updateExtractedVectors = /* @__PURE__ */ new Map();
-  if (updateVecIndexes.size > 0) {
-    const dimensionCheckVectors = /* @__PURE__ */ new Map();
-    for (const fieldPath of entry.vectorFieldPaths) {
-      const newVec = extractVectorFromDocForUpdate(document, fieldPath);
-      updateExtractedVectors.set(fieldPath, newVec);
-      if (newVec) {
-        dimensionCheckVectors.set(fieldPath, newVec);
-      }
-    }
-    if (dimensionCheckVectors.size > 0) {
-      validateVectorDimensions(dimensionCheckVectors, updateVecIndexes);
-    }
-  }
-  const { partitionDoc } = prepareUpdatePartitionDoc(document, updateExtractedVectors);
-  await ctx.executor.execute({
-    type: "update",
-    indexName,
-    docId,
-    document: partitionDoc,
-    requestId: docId
-  });
-  try {
-    updateDocumentVectors(docId, updateExtractedVectors, updateVecIndexes);
-  } catch (err) {
-    if (rollbackDoc) {
-      try {
-        await ctx.executor.execute({
-          type: "update",
-          indexName,
-          docId,
-          document: rollbackDoc,
-          requestId: docId
-        });
-      } catch (rollbackErr) {
-        console.warn(
-          `Rollback failed for doc "${docId}" during update atomicity:`,
-          rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)
-        );
-      }
-    }
-    throw err;
-  }
-  try {
-    await ctx.pluginRegistry.runHook("afterUpdate", {
-      indexName,
-      docId,
-      oldDocument: oldDocument ?? {},
-      newDocument: document
-    });
-  } catch (err) {
-    console.warn("afterUpdate plugin hook error:", err instanceof Error ? err.message : String(err));
-  }
-  ctx.flushManager?.markDirty(indexName, 0);
-  await ctx.orchestrator.replicateToWorkers({
-    type: "update",
-    indexName,
-    docId,
-    document,
-    requestId: `replicate-update-${docId}`
-  });
-  for (const [fieldPath, vec] of updateExtractedVectors) {
-    if (vec === null) continue;
-    const vecIndex = updateVecIndexes.get(fieldPath);
-    if (vecIndex) {
-      vecIndex.scheduleBuild();
-    }
-  }
-}
-async function updateDocumentBatch(ctx, indexName, updates) {
-  ctx.guardShutdown();
-  const entry = ctx.requireIndex(indexName);
-  const succeeded = [];
-  const failed = [];
-  const updateBatchManager = ctx.requireManager(indexName);
-  const updateBatchVecIndexes = updateBatchManager.getVectorIndexes();
-  const touchedVectorFields = /* @__PURE__ */ new Set();
-  for (let chunkStart = 0; chunkStart < updates.length; chunkStart += BATCH_CHUNK_SIZE) {
-    const chunkEnd = Math.min(chunkStart + BATCH_CHUNK_SIZE, updates.length);
-    for (let i = chunkStart; i < chunkEnd; i++) {
-      try {
-        await updateDocument(ctx, indexName, updates[i].docId, updates[i].document);
-        succeeded.push(updates[i].docId);
-        if (updateBatchVecIndexes.size > 0) {
-          for (const fieldPath of entry.vectorFieldPaths) {
-            const vec = extractVectorFromDocForUpdate(updates[i].document, fieldPath);
-            if (vec !== null) {
-              touchedVectorFields.add(fieldPath);
-            }
-          }
-        }
-      } catch (err) {
-        failed.push({
-          docId: updates[i].docId,
-          error: err instanceof NarsilError ? err : new NarsilError(ErrorCodes.DOC_NOT_FOUND, String(err))
-        });
-      }
-    }
-    if (chunkEnd < updates.length) {
-      await new Promise((r) => setTimeout(r, 0));
-    }
-  }
-  for (const fieldPath of touchedVectorFields) {
-    const vecIndex = updateBatchVecIndexes.get(fieldPath);
-    if (vecIndex) {
-      vecIndex.scheduleBuild();
-    }
-  }
-  return { succeeded, failed };
-}
-function extractVectorFromDocForUpdate(document, fieldPath) {
-  return extractVectorFromDoc(document, fieldPath);
-}
-function prepareUpdatePartitionDoc(document, extractedVectors) {
-  if (extractedVectors.size === 0) {
-    return { partitionDoc: document };
-  }
-  const partitionDoc = structuredClone(document);
-  for (const fieldPath of extractedVectors.keys()) {
-    deleteNestedValue(partitionDoc, fieldPath);
-  }
-  return { partitionDoc };
-}
-
-// src/workers/worker-executor.ts
-var DEFAULT_BACKPRESSURE_LIMIT = 100;
-var DEFAULT_REQUEST_TIMEOUT = 3e4;
-var SHUTDOWN_TIMEOUT = 5e3;
-function createWorkerExecutor(worker, config) {
-  const backpressureLimit = DEFAULT_BACKPRESSURE_LIMIT;
-  const requestTimeout = DEFAULT_REQUEST_TIMEOUT;
-  const pending = /* @__PURE__ */ new Map();
-  function processResponse(msg) {
-    if (!isValidWorkerResponse(msg)) {
-      return;
-    }
-    const response = msg;
-    const entry = pending.get(response.requestId);
-    if (!entry) {
-      return;
-    }
-    clearTimeout(entry.timeoutId);
-    pending.delete(response.requestId);
-    if (response.type === "error") {
-      entry.reject(new NarsilError(response.code, response.message));
-    } else {
-      entry.resolve(response.data);
-    }
-  }
-  if (typeof worker.on === "function") {
-    worker.on("message", (msg) => processResponse(msg));
-  } else if (typeof worker.addEventListener === "function") {
-    worker.addEventListener("message", (event) => {
-      const msg = event.data;
-      processResponse(msg);
-    });
-  }
-  function execute(action) {
-    if (pending.size >= backpressureLimit) {
-      return Promise.reject(
-        new NarsilError(ErrorCodes.WORKER_BUSY, `Backpressure limit of ${backpressureLimit} pending requests reached`)
-      );
-    }
-    const requestId = createRequestId();
-    const taggedAction = { ...action, requestId };
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        pending.delete(requestId);
-        reject(new NarsilError(ErrorCodes.WORKER_TIMEOUT, `Request ${requestId} timed out after ${requestTimeout}ms`));
-      }, requestTimeout);
-      pending.set(requestId, {
-        resolve,
-        reject,
-        timeoutId
-      });
-      worker.postMessage(taggedAction);
-    });
-  }
-  async function shutdown() {
-    const requestId = createRequestId();
-    const shutdownAction = { type: "shutdown", requestId };
-    const shutdownPromise = new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        pending.delete(requestId);
-        reject(new NarsilError(ErrorCodes.WORKER_TIMEOUT, "Shutdown timed out"));
-      }, SHUTDOWN_TIMEOUT);
-      pending.set(requestId, {
-        resolve: () => resolve(),
-        reject,
-        timeoutId
-      });
-      worker.postMessage(shutdownAction);
-    });
-    try {
-      await shutdownPromise;
-    } finally {
-      for (const [id, entry] of pending) {
-        clearTimeout(entry.timeoutId);
-        entry.reject(new NarsilError(ErrorCodes.WORKER_CRASHED, "Worker is shutting down"));
-        pending.delete(id);
-      }
-    }
-  }
-  return { execute, shutdown };
-}
-
-// src/workers/factory.ts
-function resolveEntryPoint() {
-  const base = import.meta.url;
-  const distIndex = base.lastIndexOf("/dist/");
-  if (distIndex !== -1) {
-    return new URL("workers/entry.mjs", base.slice(0, distIndex + 6)).href;
-  }
-  return base.replace(/\/src\/workers\/[^/]+$/, "/dist/workers/entry.mjs");
-}
-async function createWorkerFactory(entryPoint) {
-  const runtime = detectRuntime();
-  const resolvedEntry = resolveEntryPoint();
-  if (runtime.supportsWorkerThreads) {
-    const workerThreadsModule = await import('worker_threads');
-    return function nodeFactory(_workerId) {
-      const instance = new workerThreadsModule.Worker(new URL(resolvedEntry));
-      return createWorkerExecutor(instance);
-    };
-  }
-  if (runtime.supportsWebWorkers) {
-    return function webFactory(_workerId) {
-      const instance = new Worker(resolvedEntry, { type: "module" });
-      return createWorkerExecutor(instance);
-    };
-  }
-  throw new NarsilError(ErrorCodes.WORKER_CRASHED, `No worker support available on runtime "${runtime.runtime}"`);
-}
-
-// src/workers/pool.ts
-function resolveWorkerCount(requested) {
-  if (requested !== void 0 && requested > 0) {
-    return requested;
-  }
-  let cpuCount = 4;
-  try {
-    if (navigator?.hardwareConcurrency) {
-      cpuCount = navigator.hardwareConcurrency;
-    } else if (typeof process !== "undefined") {
-      const ap = process.availableParallelism;
-      if (typeof ap === "function") {
-        cpuCount = ap();
-      }
-    }
-  } catch {
-    cpuCount = 4;
-  }
-  return Math.max(2, Math.min(8, cpuCount - 1));
-}
-function createWorkerPool(config) {
-  const workerCount = resolveWorkerCount(config.count);
-  const workers = [];
-  const indexAssignment = /* @__PURE__ */ new Map();
-  let isShutdown = false;
-  function ensureWorker(slotIndex) {
-    if (!workers[slotIndex]) {
-      workers[slotIndex] = {
-        executor: config.workerFactory(slotIndex),
-        indexes: /* @__PURE__ */ new Set(),
-        memoryStats: { heapUsed: 0, heapTotal: 0, external: 0 }
-      };
-    }
-    return workers[slotIndex];
-  }
-  function assignSlot(indexName) {
-    return fnv1a(indexName) % workerCount;
-  }
-  function addIndex(indexName) {
-    if (isShutdown) {
-      throw new NarsilError(ErrorCodes.WORKER_CRASHED, "Worker pool has been shut down");
-    }
-    if (indexAssignment.has(indexName)) {
-      return;
-    }
-    const slotIndex = assignSlot(indexName);
-    const slot = ensureWorker(slotIndex);
-    slot.indexes.add(indexName);
-    indexAssignment.set(indexName, slotIndex);
-  }
-  function removeIndex(indexName) {
-    const slotIndex = indexAssignment.get(indexName);
-    if (slotIndex === void 0) {
-      return;
-    }
-    const slot = workers[slotIndex];
-    if (slot) {
-      slot.indexes.delete(indexName);
-    }
-    indexAssignment.delete(indexName);
-  }
-  function getExecutor(indexName) {
-    if (isShutdown) {
-      throw new NarsilError(ErrorCodes.WORKER_CRASHED, "Worker pool has been shut down");
-    }
-    const slotIndex = indexAssignment.get(indexName);
-    if (slotIndex === void 0) {
-      throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Index "${indexName}" is not registered in the worker pool`);
-    }
-    return workers[slotIndex].executor;
-  }
-  function getMemoryStats() {
-    const stats = [];
-    for (let i = 0; i < workers.length; i++) {
-      const slot = workers[i];
-      if (slot) {
-        stats.push({
-          workerId: i,
-          heapUsed: slot.memoryStats.heapUsed,
-          heapTotal: slot.memoryStats.heapTotal,
-          external: slot.memoryStats.external
-        });
-      }
-    }
-    return stats;
-  }
-  async function shutdown() {
-    if (isShutdown) {
-      return;
-    }
-    isShutdown = true;
-    const shutdownPromises = workers.filter(Boolean).map((slot) => {
-      const timeoutPromise = new Promise((resolve) => {
-        setTimeout(resolve, 5e3);
-      });
-      return Promise.race([slot.executor.shutdown(), timeoutPromise]);
-    });
-    await Promise.allSettled(shutdownPromises);
-    indexAssignment.clear();
-  }
-  function getAllExecutors() {
-    return workers.filter(Boolean).map((slot) => slot.executor);
-  }
-  function addIndexToAll(indexName) {
-    if (isShutdown) {
-      throw new NarsilError(ErrorCodes.WORKER_CRASHED, "Worker pool has been shut down");
-    }
-    for (let i = 0; i < workerCount; i++) {
-      const slot = ensureWorker(i);
-      slot.indexes.add(indexName);
-    }
-    indexAssignment.set(indexName, 0);
-  }
-  return {
-    getExecutor,
-    getAllExecutors,
-    get workerCount() {
-      return workerCount;
-    },
-    addIndex,
-    addIndexToAll,
-    removeIndex,
-    getMemoryStats,
-    shutdown
-  };
-}
-
-// src/engine/orchestration.ts
-function createWorkerOrchestrator(config, executor, promoter, indexRegistry, callbacks) {
-  let workerPool = null;
-  let promotionInProgress = false;
-  const promotionBuffer = [];
-  const workersEnabled = config?.workers?.enabled === true;
-  async function checkPromotion() {
-    if (!workersEnabled || promotionInProgress || workerPool) return;
-    const indexMap = /* @__PURE__ */ new Map();
-    for (const [name] of indexRegistry) {
-      const mgr = executor.getManager(name);
-      indexMap.set(name, { documentCount: mgr?.countDocuments() ?? 0 });
-    }
-    const result = promoter.check(indexMap);
-    if (result.shouldPromote) {
-      promotionInProgress = true;
-      setTimeout(() => {
-        runPromotion(result.reason).catch((err) => {
-          console.warn("Worker promotion failed:", err);
-          promotionInProgress = false;
-        });
-      }, 0);
-    }
-  }
-  async function runPromotion(reason) {
-    try {
-      const factory = await createWorkerFactory();
-      const pool = createWorkerPool({
-        count: config?.workers?.count,
-        workerFactory: factory
-      });
-      for (const [name] of indexRegistry) {
-        pool.addIndexToAll(name);
-      }
-      const allExecutors = pool.getAllExecutors();
-      for (const [name, entry] of indexRegistry) {
-        await Promise.all(
-          allExecutors.map(
-            (workerExecutor) => workerExecutor.execute({
-              type: "createIndex",
-              indexName: name,
-              config: entry.config,
-              requestId: `promote-create-${name}`
-            })
-          )
-        );
-        const manager = executor.getManager(name);
-        if (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: name,
-                  partitionId: i,
-                  data: serialized,
-                  requestId: `promote-sync-${name}-${i}`
-                })
-              )
-            );
-          }
-        }
-      }
-      workerPool = pool;
-      promoter.markPromoted();
-      if (promotionBuffer.length > 0) {
-        const buffered = [...promotionBuffer];
-        promotionBuffer.length = 0;
-        for (const action of buffered) {
-          await replicateToWorkers(action);
-        }
-      }
-      callbacks?.onPromotion?.(pool.workerCount, reason);
-    } catch (err) {
-      promotionBuffer.length = 0;
-      throw err;
-    } finally {
-      promotionInProgress = false;
-    }
-  }
-  async function replicateToWorkers(action) {
-    if (promotionInProgress) {
-      promotionBuffer.push(action);
-      return;
-    }
-    if (!workerPool) return;
-    const allExecutors = workerPool.getAllExecutors();
-    const results = await Promise.allSettled(allExecutors.map((workerExecutor) => workerExecutor.execute(action)));
-    for (const result of results) {
-      if (result.status === "rejected") {
-        console.warn("Worker replication failed:", result.reason);
-      }
-    }
-  }
-  async function searchViaWorker(indexName, params) {
-    if (!workerPool) return null;
-    const manager = executor.getManager(indexName);
-    if (!manager) return null;
-    const allExecutors = workerPool.getAllExecutors();
-    const totalPartitions = manager.partitionCount;
-    const numWorkers = allExecutors.length;
-    if (numWorkers === 0) return null;
-    if (numWorkers === 1) {
-      try {
-        return await allExecutors[0].execute({
-          type: "query",
-          indexName,
-          params,
-          requestId: createRequestId()
-        });
-      } catch (err) {
-        console.warn("Worker search failed, falling back to local:", err);
-        return null;
-      }
-    }
-    try {
-      const workerAssignments = Array.from({ length: numWorkers }, () => []);
-      for (let p = 0; p < totalPartitions; p++) {
-        workerAssignments[p % numWorkers].push(p);
-      }
-      const results = await Promise.all(
-        allExecutors.map(
-          (workerExecutor, idx) => workerExecutor.execute({
-            type: "query",
-            indexName,
-            params,
-            requestId: createRequestId(),
-            partitionIds: workerAssignments[idx]
-          })
-        )
-      );
-      const allScored = results.map((r) => r.scored);
-      const merged = kWayMerge(allScored);
-      let totalMatched = 0;
-      for (const r of results) {
-        totalMatched += r.totalMatched;
-      }
-      return { scored: merged, totalMatched };
-    } catch (err) {
-      console.warn("Parallel worker search failed, falling back to local:", err);
-      return null;
-    }
-  }
-  function isPromoted() {
-    return workerPool !== null;
-  }
-  function getMemoryStats() {
-    const workers = workerPool ? workerPool.getMemoryStats().map((s) => ({
-      workerId: s.workerId,
-      heapUsed: s.heapUsed,
-      heapTotal: s.heapTotal,
-      external: s.external
-    })) : [];
-    const totalBytes = workers.reduce((sum, w) => sum + w.heapUsed, 0);
-    return { totalBytes, workers };
-  }
-  async function shutdown() {
-    if (workerPool) {
-      await workerPool.shutdown();
-      workerPool = null;
-    }
-  }
-  return { checkPromotion, replicateToWorkers, searchViaWorker, isPromoted, getMemoryStats, shutdown };
-}
-
-// src/highlighting/highlighter.ts
-function buildTokenCharOffsets(text, originalTokens) {
-  const offsets = [];
-  let searchFrom = 0;
-  for (const token of originalTokens) {
-    const idx = text.indexOf(token, searchFrom);
-    if (idx === -1) continue;
-    offsets.push({ start: idx, end: idx + token.length });
-    searchFrom = idx + token.length;
-  }
-  return offsets;
-}
-function mergeOverlapping(ranges) {
-  if (ranges.length === 0) return [];
-  const sorted = [...ranges].sort((a, b) => a.start - b.start);
-  const merged = [sorted[0]];
-  for (let i = 1; i < sorted.length; i++) {
-    const prev = merged[merged.length - 1];
-    const curr = sorted[i];
-    if (curr.start <= prev.end) {
-      prev.end = Math.max(prev.end, curr.end);
-    } else {
-      merged.push(curr);
-    }
-  }
-  return merged;
-}
-function findDensestWindow(positions, text, windowSize) {
-  if (positions.length === 0) {
-    return { start: 0, end: Math.min(windowSize, text.length) };
-  }
-  let bestStart = 0;
-  let bestCount = 0;
-  for (const pos of positions) {
-    const windowStart = Math.max(0, pos.start - Math.floor(windowSize / 2));
-    const windowEnd = Math.min(text.length, windowStart + windowSize);
-    const adjustedStart = Math.max(0, windowEnd - windowSize);
-    let count = 0;
-    for (const p of positions) {
-      if (p.start >= adjustedStart && p.end <= windowEnd) {
-        count++;
-      }
-    }
-    if (count > bestCount) {
-      bestCount = count;
-      bestStart = adjustedStart;
-    }
-  }
-  return { start: bestStart, end: Math.min(text.length, bestStart + windowSize) };
-}
-function applySnippetTruncation(taggedText, originalText, positions, maxLen, preTag, postTag) {
-  if (maxLen <= 0 || originalText.length <= maxLen) {
-    return { snippet: taggedText, adjustedPositions: positions };
-  }
-  const window = findDensestWindow(positions, originalText, maxLen);
-  const snippetRaw = originalText.substring(window.start, window.end);
-  const adjustedPositions = [];
-  for (const pos of positions) {
-    if (pos.start >= window.start && pos.end <= window.end) {
-      adjustedPositions.push({
-        start: pos.start - window.start,
-        end: pos.end - window.start
-      });
-    }
-  }
-  let snippet = snippetRaw;
-  const sortedDesc = [...adjustedPositions].sort((a, b) => b.start - a.start);
-  for (const pos of sortedDesc) {
-    snippet = snippet.substring(0, pos.start) + preTag + snippet.substring(pos.start, pos.end) + postTag + snippet.substring(pos.end);
-  }
-  const needsLeadingEllipsis = window.start > 0;
-  const needsTrailingEllipsis = window.end < originalText.length;
-  if (needsLeadingEllipsis) snippet = `...${snippet}`;
-  if (needsTrailingEllipsis) snippet = `${snippet}...`;
-  return { snippet, adjustedPositions };
-}
-function highlightField(text, queryTokens, language, options) {
-  const preTag = options?.preTag ?? "<mark>";
-  const postTag = options?.postTag ?? "</mark>";
-  const maxSnippetLength = options?.maxSnippetLength ?? 200;
-  if (text.length === 0) {
-    return { snippet: text, positions: [] };
-  }
-  const fieldResult = tokenize(text, language, { stem: false, removeStopWords: false });
-  if (fieldResult.tokens.length === 0) {
-    return { snippet: text, positions: [] };
-  }
-  const lowercaseText = text.normalize("NFC").toLowerCase();
-  const charOffsets = buildTokenCharOffsets(lowercaseText, fieldResult.originalTokens);
-  const stemmedQueryTokens = queryTokens.map((qt) => {
-    if (language.stemmer) {
-      return language.stemmer(qt.token.toLowerCase());
-    }
-    return qt.token.toLowerCase();
-  });
-  const matchedRanges = [];
-  for (let i = 0; i < fieldResult.tokens.length; i++) {
-    if (i >= charOffsets.length) break;
-    const fieldToken = fieldResult.tokens[i].token;
-    const stemmedField = language.stemmer ? language.stemmer(fieldToken) : fieldToken;
-    for (const stemmedQuery of stemmedQueryTokens) {
-      if (stemmedField === stemmedQuery) {
-        matchedRanges.push({ start: charOffsets[i].start, end: charOffsets[i].end });
-        break;
-      }
-    }
-  }
-  const mergedPositions = mergeOverlapping(matchedRanges);
-  if (mergedPositions.length === 0) {
-    if (maxSnippetLength > 0 && text.length > maxSnippetLength) {
-      const truncated = text.substring(0, maxSnippetLength);
-      return { snippet: `${truncated}...`, positions: [] };
-    }
-    return { snippet: text, positions: [] };
-  }
-  if (maxSnippetLength > 0 && text.length > maxSnippetLength) {
-    const { snippet, adjustedPositions } = applySnippetTruncation(
-      text,
-      text,
-      mergedPositions,
-      maxSnippetLength,
-      preTag,
-      postTag
-    );
-    return { snippet, positions: adjustedPositions };
-  }
-  let result = text;
-  const sortedDesc = [...mergedPositions].sort((a, b) => b.start - a.start);
-  for (const pos of sortedDesc) {
-    result = result.substring(0, pos.start) + preTag + result.substring(pos.start, pos.end) + postTag + result.substring(pos.end);
-  }
-  return { snippet: result, positions: mergedPositions };
-}
-
-// src/search/fusion.ts
-function reciprocalRankFusion(lists, options) {
-  const k = options.k > 0 ? options.k : 60;
-  const scores = /* @__PURE__ */ new Map();
-  const docData = /* @__PURE__ */ new Map();
-  for (const list of lists) {
-    for (let rank = 0; rank < list.length; rank++) {
-      const doc = list[rank];
-      const rrfContribution = 1 / (k + rank + 1);
-      scores.set(doc.docId, (scores.get(doc.docId) ?? 0) + rrfContribution);
-      if (!docData.has(doc.docId)) {
-        docData.set(doc.docId, doc);
-      }
-    }
-  }
-  const result = [];
-  for (const [docId, score] of scores) {
-    const original = docData.get(docId);
-    if (!original) continue;
-    result.push({
-      docId,
-      score,
-      termFrequencies: original.termFrequencies,
-      fieldLengths: original.fieldLengths,
-      idf: original.idf
-    });
-  }
-  result.sort((a, b) => b.score - a.score || a.docId.localeCompare(b.docId));
-  return result;
-}
-function linearCombination(textResults, vectorResults, options) {
-  const { alpha } = options;
-  const normalizedText = minMaxNormalize(textResults);
-  const normalizedVector = minMaxNormalize(vectorResults);
-  const textScoreMap = /* @__PURE__ */ new Map();
-  for (const doc of normalizedText) {
-    textScoreMap.set(doc.docId, doc.score);
-  }
-  const textDocMap = /* @__PURE__ */ new Map();
-  for (const doc of textResults) {
-    textDocMap.set(doc.docId, doc);
-  }
-  const vectorScoreMap = /* @__PURE__ */ new Map();
-  for (const doc of normalizedVector) {
-    vectorScoreMap.set(doc.docId, doc.score);
-  }
-  const allDocIds = /* @__PURE__ */ new Set();
-  for (const doc of textResults) allDocIds.add(doc.docId);
-  for (const doc of vectorResults) allDocIds.add(doc.docId);
-  const result = [];
-  for (const docId of allDocIds) {
-    const tScore = textScoreMap.get(docId) ?? 0;
-    const vScore = vectorScoreMap.get(docId) ?? 0;
-    const combined = alpha * vScore + (1 - alpha) * tScore;
-    const original = textDocMap.get(docId);
-    result.push({
-      docId,
-      score: combined,
-      termFrequencies: original?.termFrequencies ?? {},
-      fieldLengths: original?.fieldLengths ?? {},
-      idf: original?.idf ?? {}
-    });
-  }
-  result.sort((a, b) => b.score - a.score || a.docId.localeCompare(b.docId));
-  return result;
-}
-function minMaxNormalize(docs) {
-  if (docs.length === 0) return [];
-  let min = docs[0].score;
-  let max = docs[0].score;
-  for (let i = 1; i < docs.length; i++) {
-    if (docs[i].score < min) min = docs[i].score;
-    if (docs[i].score > max) max = docs[i].score;
-  }
-  const range = max - min;
-  if (range === 0) {
-    return docs.map((d) => ({ docId: d.docId, score: 1 }));
-  }
-  return docs.map((d) => ({ docId: d.docId, score: (d.score - min) / range }));
-}
-
-// src/search/grouping.ts
-function getNestedValue2(obj, path) {
-  const segments = path.split(".");
-  let current = obj;
-  for (const segment of segments) {
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return void 0;
-    }
-    if (!Object.hasOwn(current, segment)) {
-      return void 0;
-    }
-    current = current[segment];
-  }
-  return current;
-}
-function applyGrouping(hits, group, getDocument) {
-  if (!group.fields || group.fields.length === 0) {
-    return [{ values: {}, hits }];
-  }
-  const groupMap = /* @__PURE__ */ new Map();
-  for (const hit of hits) {
-    const doc = getDocument(hit.id);
-    const fieldValues = [];
-    const valuesRecord = {};
-    for (const field of group.fields) {
-      const value = doc ? getNestedValue2(doc, field) : void 0;
-      fieldValues.push(value);
-      valuesRecord[field] = value;
-    }
-    const compositeKey = JSON.stringify(fieldValues);
-    const existing = groupMap.get(compositeKey);
-    if (existing) {
-      existing.hits.push(hit);
-    } else {
-      groupMap.set(compositeKey, { values: valuesRecord, hits: [hit] });
-    }
-  }
-  const groups = [];
-  for (const entry of groupMap.values()) {
-    let groupHits = entry.hits;
-    if (group.maxPerGroup !== void 0 && group.maxPerGroup > 0) {
-      groupHits = groupHits.slice(0, group.maxPerGroup);
-    }
-    const result = { values: entry.values, hits: groupHits };
-    if (group.reduce) {
-      try {
-        let accumulator = group.reduce.initialValue();
-        for (const hit of groupHits) {
-          const doc = getDocument(hit.id);
-          if (doc) {
-            accumulator = group.reduce.reducer(accumulator, doc, hit.score);
-          }
-        }
-        ;
-        result.reduced = accumulator;
-      } catch (err) {
-        result.reducerError = err instanceof Error ? err.message : String(err);
-      }
-    }
-    groups.push(result);
-  }
-  groups.sort((a, b) => {
-    const aScore = a.hits.length > 0 ? a.hits[0].score : 0;
-    const bScore = b.hits.length > 0 ? b.hits[0].score : 0;
-    return bScore - aScore;
-  });
-  return groups;
-}
-
-// src/search/pagination.ts
-function encodeCursor(state) {
-  const json = JSON.stringify(state);
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(json).toString("base64");
-  }
-  return btoa(json);
-}
-function decodeCursor(encoded) {
-  let json;
-  try {
-    if (typeof Buffer !== "undefined") {
-      json = Buffer.from(encoded, "base64").toString("utf-8");
-    } else {
-      json = atob(encoded);
-    }
-  } catch {
-    throw new NarsilError(ErrorCodes.SEARCH_INVALID_CURSOR, "Failed to decode cursor: invalid base64 encoding", {
-      cursor: encoded
-    });
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(json);
-  } catch {
-    throw new NarsilError(ErrorCodes.SEARCH_INVALID_CURSOR, "Failed to decode cursor: invalid JSON", {
-      cursor: encoded
-    });
-  }
-  if (!Array.isArray(parsed)) {
-    throw new NarsilError(ErrorCodes.SEARCH_INVALID_CURSOR, "Invalid cursor structure: expected an array", {
-      cursor: encoded
-    });
-  }
-  for (let i = 0; i < parsed.length; i++) {
-    const entry = parsed[i];
-    if (typeof entry !== "object" || entry === null) {
-      throw new NarsilError(
-        ErrorCodes.SEARCH_INVALID_CURSOR,
-        `Invalid cursor entry at index ${i}: expected an object`,
-        {
-          cursor: encoded,
-          index: i
-        }
-      );
-    }
-    const { s, d, p } = entry;
-    if (typeof s !== "number" || !Number.isFinite(s)) {
-      throw new NarsilError(
-        ErrorCodes.SEARCH_INVALID_CURSOR,
-        `Invalid cursor entry at index ${i}: "s" must be a finite number`,
-        { cursor: encoded, index: i }
-      );
-    }
-    if (typeof d !== "string") {
-      throw new NarsilError(
-        ErrorCodes.SEARCH_INVALID_CURSOR,
-        `Invalid cursor entry at index ${i}: "d" must be a string`,
-        { cursor: encoded, index: i }
-      );
-    }
-    if (typeof p !== "number" || !Number.isInteger(p) || p < 0) {
-      throw new NarsilError(
-        ErrorCodes.SEARCH_INVALID_CURSOR,
-        `Invalid cursor entry at index ${i}: "p" must be a non-negative integer`,
-        { cursor: encoded, index: i }
-      );
-    }
-  }
-  return parsed;
-}
-function applyPagination(results, limit, offset, cursor) {
-  if (limit <= 0) {
-    return { paginated: [] };
-  }
-  let startIndex = 0;
-  if (cursor) {
-    const cursorState = decodeCursor(cursor);
-    const anchor = cursorState[0];
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      if (result.score < anchor.s || result.score === anchor.s && result.id > anchor.d) {
-        startIndex = i;
-        break;
-      }
-      if (i === results.length - 1) {
-        startIndex = results.length;
-      }
-    }
-  }
-  const afterOffset = startIndex + offset;
-  const sliced = results.slice(afterOffset, afterOffset + limit);
-  let nextCursor;
-  const hasMore = afterOffset + limit < results.length;
-  if (hasMore && sliced.length > 0) {
-    const lastResult = sliced[sliced.length - 1];
-    const cursorState = [{ s: lastResult.score, d: lastResult.id, p: 0 }];
-    nextCursor = encodeCursor(cursorState);
-  }
-  return { paginated: sliced, nextCursor };
-}
-
-// src/search/pinning.ts
-function applyPinning(hits, pinned, resolveDoc) {
-  const result = hits.slice();
-  const pinnedDocIds = new Set(pinned.map((p) => p.docId));
-  for (let i = result.length - 1; i >= 0; i--) {
-    if (pinnedDocIds.has(result[i].id)) {
-      result.splice(i, 1);
-    }
-  }
-  const sorted = pinned.slice().sort((a, b) => a.position - b.position);
-  for (const entry of sorted) {
-    const doc = resolveDoc(entry.docId);
-    if (!doc) continue;
-    const pos = Math.max(0, Math.min(entry.position, result.length));
-    result.splice(pos, 0, doc);
-  }
-  return result;
-}
-
-// src/search/sorting.ts
-function getNestedValue3(obj, path) {
-  const segments = path.split(".");
-  let current = obj;
-  for (const segment of segments) {
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return void 0;
-    }
-    if (!Object.hasOwn(current, segment)) {
-      return void 0;
-    }
-    current = current[segment];
-  }
-  return current;
-}
-function applySorting(hits, sort, getDocument) {
-  const sortFields = Object.entries(sort);
-  if (sortFields.length === 0) return hits;
-  const collator = new Intl.Collator(void 0, { sensitivity: "base" });
-  const valueCache = /* @__PURE__ */ new Map();
-  for (const hit of hits) {
-    const doc = getDocument(hit.id);
-    if (!doc) {
-      valueCache.set(
-        hit.id,
-        sortFields.map(() => void 0)
-      );
-      continue;
-    }
-    const values = sortFields.map(([field]) => getNestedValue3(doc, field));
-    valueCache.set(hit.id, values);
-  }
-  const sorted = hits.slice();
-  sorted.sort((a, b) => {
-    const aValues = valueCache.get(a.id) ?? [];
-    const bValues = valueCache.get(b.id) ?? [];
-    for (let i = 0; i < sortFields.length; i++) {
-      const direction = sortFields[i][1];
-      const aVal = aValues[i];
-      const bVal = bValues[i];
-      const aIsNullish = aVal === void 0 || aVal === null;
-      const bIsNullish = bVal === void 0 || bVal === null;
-      if (aIsNullish && bIsNullish) continue;
-      if (aIsNullish) return 1;
-      if (bIsNullish) return -1;
-      let comparison = 0;
-      if (typeof aVal === "string" && typeof bVal === "string") {
-        comparison = collator.compare(aVal, bVal);
-      } else if (typeof aVal === "number" && typeof bVal === "number") {
-        const aIsNaN = Number.isNaN(aVal);
-        const bIsNaN = Number.isNaN(bVal);
-        if (aIsNaN && bIsNaN) continue;
-        if (aIsNaN) return 1;
-        if (bIsNaN) return -1;
-        comparison = aVal - bVal;
-      } else if (typeof aVal === "boolean" && typeof bVal === "boolean") {
-        comparison = aVal === bVal ? 0 : aVal ? 1 : -1;
-      }
-      if (comparison !== 0) {
-        return direction === "desc" ? -comparison : comparison;
-      }
-    }
-    return 0;
-  });
-  return sorted;
-}
-
-// src/engine/query.ts
-function collectFilterDocIds(manager, params, schema) {
-  const filterDocIds = /* @__PURE__ */ new Set();
-  if (!params.filters) return filterDocIds;
-  for (const partition of manager.getAllPartitions()) {
-    const partitionFiltered = partition.applyFilters(params.filters, schema);
-    for (const docId of partitionFiltered) {
-      filterDocIds.add(docId);
-    }
-  }
-  return filterDocIds;
-}
-function vectorResultsToScored(results) {
-  return results.map((r) => ({
-    docId: r.docId,
-    score: r.score,
-    termFrequencies: {},
-    fieldLengths: {},
-    idf: {}
-  }));
-}
-function resolveVectorIndex(manager, fieldName) {
-  return manager.getVectorIndexes().get(fieldName);
-}
-function executeVectorSearch(params, manager, config, limit, offset) {
-  const vectorConfig = params.vector;
-  if (!vectorConfig || !vectorConfig.value) {
-    return { scored: [], totalMatched: 0 };
-  }
-  const vecIndex = resolveVectorIndex(manager, vectorConfig.field);
-  if (!vecIndex) {
-    return { scored: [], totalMatched: 0 };
-  }
-  let filterDocIds;
-  if (params.filters) {
-    filterDocIds = collectFilterDocIds(manager, params, config.schema);
-    if (filterDocIds.size === 0) {
-      return { scored: [], totalMatched: 0 };
-    }
-  }
-  const queryVec = new Float32Array(vectorConfig.value);
-  const k = limit + offset + 1;
-  const results = vecIndex.search(queryVec, k, {
-    metric: vectorConfig.metric ?? "cosine",
-    minSimilarity: vectorConfig.similarity ?? 0,
-    filterDocIds,
-    efSearch: vectorConfig.efSearch
-  });
-  const scored = vectorResultsToScored(results);
-  return { scored, totalMatched: scored.length };
-}
-async function executeHybridSearch(params, manager, language, config, workerSearch, indexName, limit, offset) {
-  const { vector: _vector, mode: _mode, hybrid: _hybrid, ...textOnlyParams } = params;
-  let filterDocIds;
-  if (params.filters) {
-    filterDocIds = collectFilterDocIds(manager, params, config.schema);
-    if (filterDocIds.size === 0) {
-      return { scored: [], totalMatched: 0 };
-    }
-  }
-  let textFanOutResult;
-  const textWorkerResult = workerSearch ? await workerSearch(indexName, textOnlyParams) : null;
-  if (textWorkerResult) {
-    textFanOutResult = textWorkerResult;
-  } else {
-    const searchOptions = {
-      bm25Params: config.bm25,
-      stopWords: config.stopWords,
-      customTokenizer: config.tokenizer
-    };
-    textFanOutResult = await fanOutQuery(
-      manager,
-      textOnlyParams,
-      language,
-      config.schema,
-      { scoringMode: params.scoring ?? config.defaultScoring ?? "local" },
-      searchOptions
-    );
-  }
-  const vectorConfig = params.vector;
-  if (!vectorConfig || !vectorConfig.value) {
-    return {
-      scored: textFanOutResult.scored,
-      totalMatched: textFanOutResult.totalMatched,
-      facets: textFanOutResult.facets
-    };
-  }
-  let vectorScored = [];
-  const vecIndex = resolveVectorIndex(manager, vectorConfig.field);
-  if (vecIndex) {
-    const queryVec = new Float32Array(vectorConfig.value);
-    const vectorK = limit + offset + 1;
-    const vectorResults = vecIndex.search(queryVec, vectorK, {
-      metric: vectorConfig.metric ?? "cosine",
-      minSimilarity: vectorConfig.similarity ?? 0,
-      filterDocIds,
-      efSearch: vectorConfig.efSearch
-    });
-    vectorScored = vectorResultsToScored(vectorResults);
-  }
-  const hybridConfig = params.hybrid ?? {};
-  const strategy = hybridConfig.strategy ?? "rrf";
-  let fusedScored;
-  if (strategy === "rrf") {
-    const rrfK = hybridConfig.k !== void 0 && hybridConfig.k > 0 ? hybridConfig.k : 60;
-    fusedScored = reciprocalRankFusion([textFanOutResult.scored, vectorScored], { k: rrfK });
-  } else {
-    const alpha = clampAlpha(hybridConfig.alpha);
-    fusedScored = linearCombination(textFanOutResult.scored, vectorScored, { alpha });
-  }
-  if (params.minScore !== void 0 && params.minScore > 0) {
-    const threshold = params.minScore;
-    fusedScored = fusedScored.filter((doc) => doc.score >= threshold);
-  }
-  if (filterDocIds) {
-    fusedScored = fusedScored.filter((doc) => filterDocIds.has(doc.docId));
-  }
-  return {
-    scored: fusedScored,
-    totalMatched: fusedScored.length,
-    facets: textFanOutResult.facets
-  };
-}
-function clampAlpha(alpha) {
-  if (alpha === void 0) return 0.5;
-  if (!Number.isFinite(alpha)) return 0.5;
-  if (alpha < 0) return 0;
-  if (alpha > 1) return 1;
-  return alpha;
-}
-async function executeQuery(params, context) {
-  const { manager, language, config, workerSearch, indexName } = context;
-  const startTime = now();
-  const limit = clampLimit(params.limit);
-  const offset = clampOffset(params.offset);
-  const hasTerm = params.term !== void 0 && params.term.trim().length > 0;
-  const hasVector = params.vector !== void 0 && params.vector.value !== void 0;
-  const isHybridMode = params.mode === "hybrid" || hasTerm && hasVector;
-  const isVectorOnly = (params.mode === "vector" || hasVector && !hasTerm) && !isHybridMode;
-  const requestedVectorField = params.vector?.field;
-  const hasGlobalVectorIndex = requestedVectorField !== void 0 && manager.getVectorIndexes().has(requestedVectorField);
-  let fanOutResult;
-  if (isVectorOnly && hasGlobalVectorIndex) {
-    fanOutResult = executeVectorSearch(params, manager, config, limit, offset);
-  } else if (isHybridMode && hasGlobalVectorIndex) {
-    fanOutResult = await executeHybridSearch(params, manager, language, config, workerSearch, indexName, limit, offset);
-  } else {
-    const workerResult = workerSearch ? await workerSearch(indexName, params) : null;
-    if (workerResult) {
-      fanOutResult = workerResult;
-    } else {
-      const searchOptions = {
-        bm25Params: config.bm25,
-        stopWords: config.stopWords,
-        customTokenizer: config.tokenizer
-      };
-      fanOutResult = await fanOutQuery(
-        manager,
-        params,
-        language,
-        config.schema,
-        { scoringMode: params.scoring ?? config.defaultScoring ?? "local" },
-        searchOptions
-      );
-    }
-  }
-  const needsFullHits = params.sort !== void 0 || params.group !== void 0 || params.pinned !== void 0 || params.searchAfter !== void 0;
-  let hits;
-  if (needsFullHits) {
-    hits = fanOutResult.scored.map((scored) => ({
-      id: scored.docId,
-      score: scored.score,
-      document: void 0,
-      scoreComponents: params.includeScoreComponents ? { termFrequencies: scored.termFrequencies, fieldLengths: scored.fieldLengths, idf: scored.idf } : void 0
-    }));
-  } else {
-    const end = Math.min(offset + limit + 1, fanOutResult.scored.length);
-    hits = new Array(end);
-    for (let i = 0; i < end; i++) {
-      const scored = fanOutResult.scored[i];
-      hits[i] = {
-        id: scored.docId,
-        score: scored.score,
-        document: void 0,
-        scoreComponents: params.includeScoreComponents ? { termFrequencies: scored.termFrequencies, fieldLengths: scored.fieldLengths, idf: scored.idf } : void 0
-      };
-    }
-  }
-  if (params.sort) {
-    hits = applySorting(hits, params.sort, (docId) => manager.getRef(docId));
-  }
-  let groups;
-  if (params.group) {
-    groups = applyGrouping(hits, params.group, (docId) => manager.getRef(docId));
-  }
-  if (params.pinned) {
-    hits = applyPinning(hits, params.pinned, (docId) => {
-      const doc = manager.getRef(docId);
-      if (!doc) return void 0;
-      return { id: docId, score: 0, document: doc };
-    });
-  }
-  const { paginated, nextCursor } = applyPagination(hits, limit, offset, params.searchAfter);
-  for (const hit of paginated) {
-    hit.document = manager.get(hit.id) ?? {};
-  }
-  if (groups) {
-    for (const group of groups) {
-      for (const hit of group.hits) {
-        hit.document = manager.get(hit.id) ?? {};
-      }
-    }
-  }
-  if (params.highlight) {
-    applyHighlights(paginated, params, language, config);
-  }
-  const elapsed = now() - startTime;
-  return {
-    hits: paginated,
-    count: fanOutResult.totalMatched,
-    elapsed,
-    cursor: nextCursor,
-    facets: fanOutResult.facets,
-    groups
-  };
-}
-async function executePreflight(params, context) {
-  const { manager, language, config, workerSearch, indexName } = context;
-  const startTime = now();
-  const hasTerm = params.term !== void 0 && params.term.trim().length > 0;
-  const hasVector = params.vector !== void 0 && params.vector.value !== void 0;
-  const isHybridMode = params.mode === "hybrid" || hasTerm && hasVector;
-  const isVectorOnly = (params.mode === "vector" || hasVector && !hasTerm) && !isHybridMode;
-  const requestedVectorField = params.vector?.field;
-  const hasGlobalVectorIndex = requestedVectorField !== void 0 && manager.getVectorIndexes().has(requestedVectorField);
-  let totalMatched;
-  const preflightLimit = 1e3;
-  const preflightOffset = 0;
-  if (isVectorOnly && hasGlobalVectorIndex) {
-    const result = executeVectorSearch(params, manager, config, preflightLimit, preflightOffset);
-    totalMatched = result.totalMatched;
-  } else if (isHybridMode && hasGlobalVectorIndex) {
-    const result = await executeHybridSearch(
-      params,
-      manager,
-      language,
-      config,
-      workerSearch,
-      indexName,
-      preflightLimit,
-      preflightOffset
-    );
-    totalMatched = result.totalMatched;
-  } else {
-    const workerResult = workerSearch ? await workerSearch(indexName, params) : null;
-    if (workerResult) {
-      totalMatched = workerResult.totalMatched;
-    } else {
-      const searchOptions = {
-        bm25Params: config.bm25,
-        stopWords: config.stopWords,
-        customTokenizer: config.tokenizer
-      };
-      const fanOutResult = await fanOutQuery(
-        manager,
-        params,
-        language,
-        config.schema,
-        { scoringMode: params.scoring ?? config.defaultScoring ?? "local" },
-        searchOptions
-      );
-      totalMatched = fanOutResult.totalMatched;
-    }
-  }
-  const elapsed = now() - startTime;
-  return { count: totalMatched, elapsed };
-}
-function applyHighlights(hits, params, language, config) {
-  if (!params.highlight) return;
-  const queryTokenResult = tokenize(params.term ?? "", language, {
-    stem: true,
-    removeStopWords: true,
-    customTokenizer: config.tokenizer,
-    stopWordOverride: config.stopWords
-  });
-  for (const hit of hits) {
-    const highlights = {};
-    for (const field of params.highlight.fields) {
-      const doc = hit.document;
-      const fieldValue = doc[field];
-      if (typeof fieldValue === "string") {
-        highlights[field] = highlightField(fieldValue, queryTokenResult.tokens, language, {
-          preTag: params.highlight.preTag,
-          postTag: params.highlight.postTag,
-          maxSnippetLength: params.highlight.maxSnippetLength
-        });
-      }
-    }
-    hit.highlights = highlights;
-  }
-}
-
-// src/partitioning/write-ahead-queue.ts
-function createWriteAheadQueue(maxSize = 1e4) {
-  const entries = [];
-  let nextSequence = 1;
-  return {
-    push(entry) {
-      if (entries.length >= maxSize) {
-        throw new NarsilError(
-          ErrorCodes.PARTITION_REBALANCING_BACKPRESSURE,
-          `Write-ahead queue is full (${maxSize} entries). Retry after rebalancing completes.`,
-          { maxSize, currentSize: entries.length }
-        );
-      }
-      const seq = nextSequence++;
-      entries.push({ ...entry, sequenceNumber: seq });
-      return seq;
-    },
-    drain() {
-      const result = entries.splice(0);
-      result.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
-      return result;
-    },
-    clear() {
-      entries.length = 0;
-    },
-    get size() {
-      return entries.length;
-    },
-    get isFull() {
-      return entries.length >= maxSize;
-    }
-  };
-}
-
-// src/engine/rebalance-executor.ts
-async function executeRebalance(manager, indexName, targetPartitionCount, ctx) {
-  if (targetPartitionCount <= 0 || !Number.isInteger(targetPartitionCount)) {
-    throw new NarsilError(
-      ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
-      `Target partition count must be a positive integer, got ${targetPartitionCount}`,
-      { targetPartitionCount }
-    );
-  }
-  if (ctx.rebalancingIndexes.has(indexName)) {
-    throw new NarsilError(
-      ErrorCodes.PARTITION_REBALANCING_BACKPRESSURE,
-      `Index "${indexName}" is already being rebalanced`
-    );
-  }
-  if (targetPartitionCount === manager.partitionCount) {
-    return;
-  }
-  const waq = createWriteAheadQueue();
-  ctx.waqMap.set(indexName, waq);
-  ctx.rebalancingIndexes.add(indexName);
-  try {
-    const oldCount = manager.partitionCount;
-    await ctx.rebalancer.rebalance(manager, targetPartitionCount, ctx.router, (progress) => {
-      if (progress.phase === "complete") {
-        const handlers = ctx.eventHandlers.get("partitionRebalance");
-        if (handlers) {
-          for (const handler of handlers) {
-            handler({ indexName, oldCount, newCount: targetPartitionCount });
-          }
-        }
-      }
-    });
-    const entries = waq.drain();
-    const appliedSeqs = ctx.lastAppliedSeqMap.get(indexName) ?? /* @__PURE__ */ new Map();
-    const rebalanceEntry = ctx.requireIndex(indexName);
-    const rebalanceVecIndexes = manager.getVectorIndexes();
-    const rebalanceVectorFieldPaths = rebalanceVecIndexes.size > 0 ? rebalanceEntry.vectorFieldPaths : /* @__PURE__ */ new Set();
-    for (const entry of entries) {
-      const partitionLastSeq = appliedSeqs.get(0) ?? 0;
-      if (entry.sequenceNumber <= partitionLastSeq) continue;
-      try {
-        if (entry.action === "insert" && entry.document) {
-          const { partitionDoc, extractedVectors } = prepareDocumentVectors(
-            entry.document,
-            rebalanceVectorFieldPaths,
-            rebalanceVecIndexes
-          );
-          manager.insert(entry.docId, partitionDoc);
-          if (extractedVectors.size > 0) {
-            insertDocumentVectors(entry.docId, extractedVectors, rebalanceVecIndexes);
-          }
-        } else if (entry.action === "remove") {
-          manager.remove(entry.docId);
-          removeDocumentVectors(entry.docId, rebalanceVecIndexes);
-        } else if (entry.action === "update" && entry.document) {
-          const replayUpdateVectors = /* @__PURE__ */ new Map();
-          for (const fieldPath of rebalanceVectorFieldPaths) {
-            const newVec = extractVectorFromDoc(entry.document, fieldPath);
-            replayUpdateVectors.set(fieldPath, newVec);
-          }
-          const replayUpdateDoc = replayUpdateVectors.size > 0 ? structuredClone(entry.document) : entry.document;
-          if (replayUpdateVectors.size > 0) {
-            for (const fieldPath of replayUpdateVectors.keys()) {
-              deleteNestedValue(replayUpdateDoc, fieldPath);
-            }
-          }
-          manager.update(entry.docId, replayUpdateDoc);
-          for (const [fieldPath, newVec] of replayUpdateVectors) {
-            const vecIndex = rebalanceVecIndexes.get(fieldPath);
-            if (!vecIndex) continue;
-            if (newVec === null) {
-              if (vecIndex.has(entry.docId)) {
-                vecIndex.remove(entry.docId);
-              }
-            } else {
-              const oldVec = vecIndex.getVector(entry.docId);
-              if (!vectorsEqual(oldVec, newVec)) {
-                vecIndex.remove(entry.docId);
-                vecIndex.insert(entry.docId, newVec);
-              }
-            }
-          }
-        }
-      } catch (replayErr) {
-        const isDuplicate = replayErr instanceof NarsilError && replayErr.code === ErrorCodes.DOC_ALREADY_EXISTS;
-        const isMissing = replayErr instanceof NarsilError && replayErr.code === ErrorCodes.DOC_NOT_FOUND;
-        if (!isDuplicate && !isMissing) {
-          console.warn(`WAQ replay failed for ${entry.action} on doc "${entry.docId}":`, replayErr);
-        }
-      }
-      appliedSeqs.set(0, entry.sequenceNumber);
-    }
-    ctx.lastAppliedSeqMap.set(indexName, appliedSeqs);
-  } finally {
-    ctx.rebalancingIndexes.delete(indexName);
-    ctx.waqMap.delete(indexName);
-  }
-}
-
-// src/engine/resolve-vector-text.ts
-async function resolveVectorText(params, embeddingAdapter, signal) {
-  if (!params.vector) return params;
-  if (params.vector.text === void 0 && params.vector.value === void 0) return params;
-  if (params.vector.value !== void 0 && params.vector.text === void 0) return params;
-  if (params.vector.text !== void 0 && params.vector.value !== void 0) {
-    throw new NarsilError(ErrorCodes.EMBEDDING_CONFIG_INVALID, "Vector query cannot have both 'text' and 'value'");
-  }
-  if (!embeddingAdapter) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_CONFIG_INVALID,
-      "Vector query with 'text' requires an embedding adapter on the index or instance"
-    );
-  }
-  if (typeof params.vector.text !== "string") {
-    throw new NarsilError(
-      ErrorCodes.DOC_VALIDATION_FAILED,
-      `Vector query 'text' must be a string, got ${typeof params.vector.text}`
-    );
-  }
-  if (params.vector.text.length === 0) {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Vector query 'text' must not be empty");
-  }
-  const raw = await embeddingAdapter.embed(params.vector.text, "query", signal);
-  if (!(raw instanceof Float32Array)) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_FAILED,
-      `Adapter returned ${typeof raw} for query embedding, expected Float32Array`
-    );
-  }
-  if (raw.length !== embeddingAdapter.dimensions) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_DIMENSION_MISMATCH,
-      `Adapter returned ${raw.length}-dimensional vector for query, expected ${embeddingAdapter.dimensions}`,
-      { expected: embeddingAdapter.dimensions, actual: raw.length }
-    );
-  }
-  const resolved = { ...params.vector, value: Array.from(raw) };
-  delete resolved.text;
-  return { ...params, vector: resolved };
-}
-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)) {
-    return value;
-  }
-  return void 0;
-}
-function wireToPartition(raw) {
-  const documents = {};
-  for (const [docId, doc] of Object.entries(raw.documents ?? {})) {
-    documents[docId] = {
-      fields: doc.fields,
-      fieldLengths: doc.field_lengths ?? {}
-    };
-  }
-  const invertedIndex = {};
-  for (const [token, list] of Object.entries(raw.inverted_index ?? {})) {
-    invertedIndex[token] = {
-      docFrequency: list.doc_freq,
-      postings: (list.postings ?? []).map((p) => ({
-        docId: p.doc_id,
-        termFrequency: p.term_freq,
-        field: p.field,
-        positions: p.positions ?? []
-      }))
-    };
-  }
-  const numeric = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.numeric ?? {})) {
-    numeric[field] = entries.map((e) => ({ value: e.value, docId: e.doc_id }));
-  }
-  const boolean = {};
-  for (const [field, idx] of Object.entries(raw.field_indexes?.boolean ?? {})) {
-    boolean[field] = { trueDocs: idx.true_docs ?? [], falseDocs: idx.false_docs ?? [] };
-  }
-  const geopoint = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.geopoint ?? {})) {
-    geopoint[field] = entries.map((e) => ({ lat: e.lat, lon: e.lon, docId: e.doc_id }));
-  }
-  const vectorData = {};
-  for (const [field, data] of Object.entries(raw.vector_data ?? {})) {
-    vectorData[field] = {
-      dimension: data.dimension,
-      vectors: (data.vectors ?? []).map((v) => ({ docId: v.doc_id, vector: v.vector })),
-      hnswGraph: data.hnsw_graph ? {
-        entryPoint: data.hnsw_graph.entry_point,
-        maxLayer: data.hnsw_graph.max_layer,
-        m: data.hnsw_graph.m,
-        efConstruction: data.hnsw_graph.ef_construction,
-        metric: validateHnswMetric(data.hnsw_graph.metric),
-        nodes: data.hnsw_graph.nodes
-      } : null,
-      sq8: data.sq8 ? {
-        alpha: data.sq8.alpha,
-        offset: data.sq8.offset,
-        quantizedVectors: data.sq8.quantized_vectors,
-        vectorSums: data.sq8.vector_sums,
-        vectorSumSqs: data.sq8.vector_sum_sqs
-      } : null
-    };
-  }
-  return {
-    indexName: raw.index_name,
-    partitionId: raw.partition_id,
-    totalPartitions: raw.total_partitions,
-    language: raw.language ?? "english",
-    schema: raw.schema ?? {},
-    docCount: raw.doc_count ?? 0,
-    avgDocLength: raw.avg_doc_length ?? 0,
-    documents,
-    invertedIndex,
-    fieldIndexes: {
-      numeric,
-      boolean,
-      enum: raw.field_indexes?.enum ?? {},
-      geopoint
-    },
-    vectorData,
-    statistics: {
-      totalDocuments: raw.statistics?.total_documents ?? 0,
-      totalFieldLengths: raw.statistics?.total_field_lengths ?? {},
-      averageFieldLengths: raw.statistics?.average_field_lengths ?? {},
-      docFrequencies: raw.statistics?.doc_frequencies ?? {}
-    }
-  };
-}
-function deserializePayloadV1(data) {
-  const raw = decode(data);
-  return wireToPartition(raw);
-}
-
-// src/engine/snapshot.ts
-async function createSnapshot(manager, entry) {
-  const partitionBuffers = [];
-  for (let i = 0; i < manager.partitionCount; i++) {
-    partitionBuffers.push(manager.serializePartitionToBytes(i));
-  }
-  const snapshotVecIndexes = manager.getVectorIndexes();
-  const vectorPayloads = {};
-  for (const [fieldPath, vecIndex] of snapshotVecIndexes) {
-    vectorPayloads[fieldPath] = vecIndex.serialize();
-  }
-  const { encode: encode2 } = await import('@msgpack/msgpack');
-  return encode2({
-    version: 2,
-    schema: entry.config.schema,
-    language: entry.language.name,
-    partitions: partitionBuffers,
-    vectorIndexes: vectorPayloads
-  });
-}
-async function restoreFromSnapshot(indexName, data, executor, indexRegistry, getVectorFieldPaths2, dropIndex, requireManager) {
-  if (!(data instanceof Uint8Array)) {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Snapshot data must be a Uint8Array");
-  }
-  const { decode: decode2 } = await import('@msgpack/msgpack');
-  const envelope = decode2(data);
-  if (envelope.version !== 1 && envelope.version !== 2) {
-    throw new NarsilError(
-      ErrorCodes.DOC_VALIDATION_FAILED,
-      `Unsupported snapshot version: ${envelope.version}. Expected version 1 or 2`,
-      { version: envelope.version }
-    );
-  }
-  if (!envelope.schema || typeof envelope.schema !== "object") {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Invalid snapshot: missing or invalid schema");
-  }
-  if (!envelope.language || typeof envelope.language !== "string") {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Invalid snapshot: missing or invalid language");
-  }
-  if (!Array.isArray(envelope.partitions)) {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Invalid snapshot: missing partitions");
-  }
-  const language = getLanguage(envelope.language);
-  const schema = envelope.schema;
-  validateSchema(schema);
-  if (indexRegistry.has(indexName)) {
-    await dropIndex(indexName);
-  }
-  const indexConfig = { schema, language: envelope.language };
-  executor.createIndex(indexName, indexConfig, language);
-  const vectorFieldPaths = getVectorFieldPaths2(schema);
-  indexRegistry.set(indexName, { config: indexConfig, language, embeddingAdapter: null, vectorFieldPaths });
-  try {
-    const manager = requireManager(indexName);
-    while (manager.partitionCount < envelope.partitions.length) {
-      manager.addPartition();
-    }
-    const deserializePartitionPayload = envelope.version === 2 ? deserializePayloadV2 : deserializePayloadV1;
-    for (let i = 0; i < envelope.partitions.length; i++) {
-      const partition = deserializePartitionPayload(envelope.partitions[i]);
-      manager.deserializePartition(i, partition);
-    }
-    if (envelope.vectorIndexes) {
-      const restoreVecIndexes = manager.getVectorIndexes();
-      for (const [fieldPath, payload] of Object.entries(envelope.vectorIndexes)) {
-        const vecIndex = restoreVecIndexes.get(fieldPath);
-        if (vecIndex) {
-          vecIndex.deserialize(payload);
-        }
-      }
-    }
-  } catch (err) {
-    try {
-      executor.dropIndex(indexName);
-      indexRegistry.delete(indexName);
-    } catch (_) {
-    }
-    throw err;
-  }
-}
-
-// src/engine/suggest.ts
-function executeSuggest(manager, language, params) {
-  const t0 = performance.now();
-  const limit = Math.max(1, Math.min(params.limit ?? 10, 100));
-  const rawPrefix = params.prefix.trim();
-  if (rawPrefix.length === 0) {
-    return { terms: [], elapsed: performance.now() - t0 };
-  }
-  const unstemmed = tokenize(rawPrefix, language, { stem: false, removeStopWords: false });
-  const lastToken = unstemmed.tokens.length > 0 ? unstemmed.tokens[unstemmed.tokens.length - 1].token : rawPrefix.toLowerCase();
-  if (lastToken.length === 0) {
-    return { terms: [], elapsed: performance.now() - t0 };
-  }
-  const stemmed = language.stemmer ? language.stemmer(lastToken) : lastToken;
-  const prefixes = stemmed !== lastToken ? [lastToken, stemmed] : [lastToken];
-  const partitions = manager.getAllPartitions();
-  const merged = /* @__PURE__ */ new Map();
-  const perPartitionLimit = limit * 2;
-  for (const partition of partitions) {
-    const seen = /* @__PURE__ */ new Set();
-    for (const prefix of prefixes) {
-      const suggestions = partition.suggestTerms(prefix, perPartitionLimit);
-      for (const s of suggestions) {
-        if (seen.has(s.term)) continue;
-        seen.add(s.term);
-        merged.set(s.term, (merged.get(s.term) ?? 0) + s.documentFrequency);
-      }
-    }
-  }
-  const terms = Array.from(merged.entries()).map(([term, documentFrequency]) => ({ term, documentFrequency })).sort((a, b) => b.documentFrequency - a.documentFrequency);
-  if (terms.length > limit) terms.length = limit;
-  return { terms, elapsed: performance.now() - t0 };
-}
-
-// src/engine/vector-maintenance.ts
-function resolveVectorIndexes(manager, indexName, fieldName) {
-  const all = manager.getVectorIndexes();
-  if (fieldName === void 0) return all;
-  const idx = all.get(fieldName);
-  if (!idx) {
-    throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Vector field "${fieldName}" not found in index "${indexName}"`, {
-      indexName,
-      fieldName
-    });
-  }
-  const single = /* @__PURE__ */ new Map();
-  single.set(fieldName, idx);
-  return single;
-}
-function compactVectors(manager, indexName, fieldName) {
-  const indexes = resolveVectorIndexes(manager, indexName, fieldName);
-  for (const [, idx] of indexes) {
-    idx.compact();
-  }
-}
-async function optimizeVectors(manager, indexName, fieldName) {
-  const indexes = resolveVectorIndexes(manager, indexName, fieldName);
-  for (const [, idx] of indexes) {
-    await idx.optimize();
-  }
-}
-function getVectorMaintenanceStatus(manager) {
-  const indexes = manager.getVectorIndexes();
-  const results = [];
-  for (const [field, idx] of indexes) {
-    const status = idx.maintenanceStatus();
-    results.push({
-      fieldName: field,
-      tombstoneRatio: status.tombstoneRatio,
-      graphCount: status.graphCount,
-      bufferSize: status.bufferSize,
-      building: status.building,
-      estimatedCompactMs: status.estimatedCompactMs,
-      estimatedOptimizeMs: status.estimatedOptimizeMs
-    });
-  }
-  return results;
-}
-
-// src/partitioning/rebalancer.ts
-var CHUNK_SIZE = 1e3;
-function createRebalancer() {
-  let rebalancing = false;
-  async function rebalance(manager, newPartitionCount, router, onProgress) {
-    if (rebalancing) {
-      throw new NarsilError(
-        ErrorCodes.PARTITION_REBALANCING_BACKPRESSURE,
-        "A rebalance operation is already in progress"
-      );
-    }
-    if (newPartitionCount <= 0) {
-      throw new NarsilError(
-        ErrorCodes.PARTITION_REBALANCING_BACKPRESSURE,
-        `New partition count must be greater than 0, received ${newPartitionCount}`,
-        { newPartitionCount }
-      );
-    }
-    if (newPartitionCount === manager.partitionCount) {
-      throw new NarsilError(
-        ErrorCodes.PARTITION_REBALANCING_BACKPRESSURE,
-        `New partition count (${newPartitionCount}) is the same as the current count`,
-        { newPartitionCount, currentPartitionCount: manager.partitionCount }
-      );
-    }
-    rebalancing = true;
-    try {
-      const collectedDocs = [];
-      const currentPartitions = manager.getAllPartitions();
-      for (const partition of currentPartitions) {
-        for (const docId of partition.docIds()) {
-          const document = partition.get(docId);
-          if (document) {
-            collectedDocs.push({ docId, document });
-          }
-        }
-      }
-      const documentsTotal = collectedDocs.length;
-      onProgress?.({
-        phase: "scanning",
-        documentsProcessed: 0,
-        documentsTotal
-      });
-      const newPartitions = [];
-      for (let i = 0; i < newPartitionCount; i++) {
-        newPartitions.push(createPartitionIndex(i));
-      }
-      let documentsProcessed = 0;
-      for (let chunkStart = 0; chunkStart < collectedDocs.length; chunkStart += CHUNK_SIZE) {
-        const chunkEnd = Math.min(chunkStart + CHUNK_SIZE, collectedDocs.length);
-        for (let i = chunkStart; i < chunkEnd; i++) {
-          const { docId, document } = collectedDocs[i];
-          const targetPartitionId = router.route(docId, newPartitionCount);
-          const targetPartition = newPartitions[targetPartitionId];
-          if (targetPartition.has(docId)) {
-            continue;
-          }
-          targetPartition.insert(docId, document, manager.schema, manager.language, { validate: false });
-          documentsProcessed++;
-        }
-        onProgress?.({
-          phase: "moving",
-          documentsProcessed,
-          documentsTotal
-        });
-        await new Promise((resolve) => setTimeout(resolve, 0));
-      }
-      onProgress?.({
-        phase: "swapping",
-        documentsProcessed,
-        documentsTotal
-      });
-      manager.setPartitions(newPartitions);
-      onProgress?.({
-        phase: "complete",
-        documentsProcessed,
-        documentsTotal
-      });
-    } finally {
-      rebalancing = false;
-    }
-  }
-  return {
-    rebalance,
-    isRebalancing() {
-      return rebalancing;
-    }
-  };
-}
-
-// src/persistence/flush-manager.ts
-var DEFAULT_INTERVAL = 5e3;
-var DEFAULT_MUTATION_THRESHOLD = 1e3;
-var DEFAULT_MAX_RETRIES = 3;
-var DEFAULT_BASE_RETRY_DELAY = 100;
-function createFlushManager(config, getPartitionData, getInstanceId) {
-  const {
-    persistence,
-    invalidation,
-    interval = DEFAULT_INTERVAL,
-    mutationThreshold = DEFAULT_MUTATION_THRESHOLD,
-    maxRetries = DEFAULT_MAX_RETRIES,
-    baseRetryDelay = DEFAULT_BASE_RETRY_DELAY,
-    onError
-  } = config;
-  const dirtyPartitions = /* @__PURE__ */ new Map();
-  let mutationCount = 0;
-  let flushTimerId = null;
-  let isShuttingDown = false;
-  let flushPromise = null;
-  function startTimer() {
-    if (flushTimerId !== null || isShuttingDown) {
-      return;
-    }
-    flushTimerId = setInterval(() => {
-      flush();
-    }, interval);
-  }
-  function addToDirtySet(indexName, partitionId) {
-    let partitions = dirtyPartitions.get(indexName);
-    if (partitions === void 0) {
-      partitions = /* @__PURE__ */ new Set();
-      dirtyPartitions.set(indexName, partitions);
-    }
-    partitions.add(partitionId);
-  }
-  function snapshotAndClearDirty() {
-    const snapshot = /* @__PURE__ */ new Map();
-    for (const [indexName, partitions] of dirtyPartitions) {
-      snapshot.set(indexName, new Set(partitions));
-    }
-    dirtyPartitions.clear();
-    return snapshot;
-  }
-  async function saveWithRetry(indexName, partitionId) {
-    const key = `${indexName}/${partitionId}`;
-    const data = getPartitionData(indexName, partitionId);
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      try {
-        await persistence.save(key, data);
-        return true;
-      } catch (err) {
-        const isLastAttempt = attempt === maxRetries - 1;
-        if (isLastAttempt) {
-          onError?.(indexName, partitionId, err, true);
-          return false;
-        }
-        const cappedAttempt = Math.min(attempt, 20);
-        const delay = baseRetryDelay * 2 ** cappedAttempt * (0.5 + Math.random() * 0.5);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-    return false;
-  }
-  async function performFlush() {
-    const snapshot = snapshotAndClearDirty();
-    for (const [indexName, partitions] of snapshot) {
-      const succeededPartitions = [];
-      for (const partitionId of partitions) {
-        const saved = await saveWithRetry(indexName, partitionId);
-        if (saved) {
-          succeededPartitions.push(partitionId);
-        } else {
-          addToDirtySet(indexName, partitionId);
-        }
-      }
-      if (succeededPartitions.length > 0) {
-        await invalidation.publish({
-          type: "partition",
-          indexName,
-          partitions: succeededPartitions,
-          timestamp: Date.now(),
-          sourceInstanceId: getInstanceId()
-        });
-      }
-    }
-    mutationCount = 0;
-  }
-  function flush() {
-    if (flushPromise !== null) {
-      return flushPromise;
-    }
-    flushPromise = performFlush().finally(() => {
-      flushPromise = null;
-    });
-    return flushPromise;
-  }
-  function markDirty(indexName, partitionId) {
-    if (isShuttingDown) return;
-    addToDirtySet(indexName, partitionId);
-    mutationCount++;
-    if (mutationCount >= mutationThreshold) {
-      flush();
-    }
-    startTimer();
-  }
-  async function shutdown() {
-    isShuttingDown = true;
-    if (flushTimerId !== null) {
-      clearInterval(flushTimerId);
-      flushTimerId = null;
-    }
-    await flush();
-  }
-  return {
-    markDirty,
-    flush,
-    shutdown
-  };
-}
-
-// src/plugins/registry.ts
-function isThenable(value) {
-  return value !== null && typeof value === "object" && typeof value.then === "function";
-}
-async function continueAsync(pending, hooks, startIndex, context) {
-  await pending;
-  for (let i = startIndex; i < hooks.length; i++) {
-    await hooks[i](context);
-  }
-}
-function createPluginRegistry() {
-  const plugins = [];
-  return {
-    register(plugin) {
-      plugins.push(plugin);
-    },
-    hasHooks(hookName) {
-      return plugins.some((p) => typeof p[hookName] === "function");
-    },
-    runHook(hookName, context) {
-      const hooks = [];
-      for (const plugin of plugins) {
-        const hook = plugin[hookName];
-        if (typeof hook === "function") {
-          hooks.push(hook.bind(plugin));
-        }
-      }
-      if (hooks.length === 0) return;
-      for (let i = 0; i < hooks.length; i++) {
-        const result = hooks[i](context);
-        if (isThenable(result)) {
-          return continueAsync(result, hooks, i + 1, context);
-        }
-      }
-    }
-  };
-}
-
-// src/schema/embedding-validator.ts
-var VECTOR_DIMENSION_PATTERN = /^vector\[(\d+)]$/;
-function validateEmbeddingConfig(embeddingConfig, schema, instanceAdapter) {
-  const fieldEntries = Object.keys(embeddingConfig.fields);
-  if (fieldEntries.length === 0) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_CONFIG_INVALID,
-      "Embedding config must define at least one field mapping"
-    );
-  }
-  const resolvedAdapter = embeddingConfig.adapter ?? instanceAdapter;
-  if (!resolvedAdapter) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_CONFIG_INVALID,
-      "Embedding config requires an adapter (set on the index or the instance)"
-    );
-  }
-  if (typeof resolvedAdapter.dimensions !== "number" || !Number.isInteger(resolvedAdapter.dimensions) || resolvedAdapter.dimensions <= 0) {
-    throw new NarsilError(
-      ErrorCodes.EMBEDDING_CONFIG_INVALID,
-      `Adapter dimensions must be a positive integer, got ${resolvedAdapter.dimensions}`
-    );
-  }
-  const flatFields = flattenSchema(schema);
-  for (const [targetField, sourceFields] of Object.entries(embeddingConfig.fields)) {
-    const targetType = flatFields[targetField];
-    if (targetType === void 0) {
-      throw new NarsilError(
-        ErrorCodes.EMBEDDING_CONFIG_INVALID,
-        `Embedding target field "${targetField}" does not exist in the schema`,
-        { field: targetField }
-      );
-    }
-    const vectorMatch = VECTOR_DIMENSION_PATTERN.exec(targetType);
-    if (!vectorMatch) {
-      throw new NarsilError(
-        ErrorCodes.EMBEDDING_CONFIG_INVALID,
-        `Embedding target field "${targetField}" must be a vector type, got "${targetType}"`,
-        { field: targetField, type: targetType }
-      );
-    }
-    const schemaDimension = Number.parseInt(vectorMatch[1], 10);
-    if (schemaDimension !== resolvedAdapter.dimensions) {
-      throw new NarsilError(
-        ErrorCodes.EMBEDDING_DIMENSION_MISMATCH,
-        `Embedding target field "${targetField}" has dimension ${schemaDimension} but the adapter produces ${resolvedAdapter.dimensions}-dimensional vectors`,
-        { field: targetField, expected: schemaDimension, actual: resolvedAdapter.dimensions }
-      );
-    }
-    const sources = Array.isArray(sourceFields) ? sourceFields : [sourceFields];
-    if (sources.length === 0) {
-      throw new NarsilError(
-        ErrorCodes.EMBEDDING_CONFIG_INVALID,
-        `Embedding target field "${targetField}" must have at least one source field`,
-        { field: targetField }
-      );
-    }
-    for (const source of sources) {
-      const sourceType = flatFields[source];
-      if (sourceType === void 0) {
-        throw new NarsilError(
-          ErrorCodes.EMBEDDING_CONFIG_INVALID,
-          `Embedding source field "${source}" does not exist in the schema`,
-          { field: source, targetField }
-        );
-      }
-      if (sourceType !== "string") {
-        throw new NarsilError(
-          ErrorCodes.EMBEDDING_CONFIG_INVALID,
-          `Embedding source field "${source}" must be a string type, got "${sourceType}"`,
-          { field: source, type: sourceType, targetField }
-        );
-      }
-    }
-  }
-  return resolvedAdapter;
-}
-function validateRequiredFieldsInSchema(required, schema) {
-  if (required.length === 0) return;
-  const flatFields = flattenSchema(schema);
-  for (const field of required) {
-    if (flatFields[field] === void 0) {
-      throw new NarsilError(
-        ErrorCodes.EMBEDDING_CONFIG_INVALID,
-        `Required field "${field}" does not exist in the schema`,
-        { field }
-      );
-    }
-  }
-}
-
-// 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/narsil.ts
-function getVectorFieldPaths(schema) {
-  return new Set(extractVectorFieldsFromSchema(schema).keys());
-}
-async function createNarsil(config) {
-  const executor = createDirectExecutor();
-  const promoter = createExecutionPromoter({
-    perIndexThreshold: config?.workers?.promotionThreshold,
-    totalThreshold: config?.workers?.totalPromotionThreshold
-  });
-  const pluginRegistry = createPluginRegistry();
-  if (config?.plugins) {
-    for (const plugin of config.plugins) pluginRegistry.register(plugin);
-  }
-  let flushManager = null;
-  if (config?.persistence) {
-    const noopInvalidation = config.invalidation ?? {
-      publish: async () => {
-      },
-      subscribe: async () => {
-      },
-      shutdown: async () => {
-      }
-    };
-    flushManager = createFlushManager(
-      {
-        persistence: config.persistence,
-        invalidation: noopInvalidation,
-        interval: config.flush?.interval,
-        mutationThreshold: config.flush?.mutationThreshold
-      },
-      () => new Uint8Array(0),
-      () => "instance-0"
-    );
-  }
-  const idGenerator = config?.idGenerator ?? generateId;
-  const indexRegistry = /* @__PURE__ */ new Map();
-  const eventHandlers = /* @__PURE__ */ new Map();
-  let isShutdown = false;
-  const abortController = new AbortController();
-  const orchestrator = createWorkerOrchestrator(config, executor, promoter, indexRegistry, {
-    onPromotion(workerCount, reason) {
-      const handlers = eventHandlers.get("workerPromote");
-      if (handlers) {
-        for (const handler of handlers) handler({ workerCount, reason });
-      }
-    }
-  });
-  const rebalancer = createRebalancer();
-  const rebalanceRouter = createPartitionRouter();
-  const rebalancingIndexes = /* @__PURE__ */ new Set();
-  const waqMap = /* @__PURE__ */ new Map();
-  const lastAppliedSeqMap = /* @__PURE__ */ new Map();
-  function guardShutdown() {
-    if (isShutdown) {
-      throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, "This Narsil instance has been shut down");
-    }
-  }
-  function requireIndex(indexName) {
-    const entry = indexRegistry.get(indexName);
-    if (!entry) {
-      throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Index "${indexName}" does not exist`, { indexName });
-    }
-    return entry;
-  }
-  function bufferIfRebalancing(indexName, entry) {
-    if (!rebalancingIndexes.has(indexName)) return false;
-    const waq = waqMap.get(indexName);
-    if (!waq) return false;
-    const clonedEntry = entry.document ? { ...entry, document: structuredClone(entry.document) } : entry;
-    waq.push(clonedEntry);
-    return true;
-  }
-  function requireManager(indexName) {
-    const manager = executor.getManager(indexName);
-    if (!manager) {
-      throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `Index "${indexName}" manager not found`, { indexName });
-    }
-    return manager;
-  }
-  const mutationCtx = {
-    executor,
-    pluginRegistry,
-    flushManager,
-    orchestrator,
-    idGenerator,
-    abortController,
-    guardShutdown,
-    requireIndex,
-    requireManager,
-    bufferIfRebalancing
-  };
-  const rebalanceCtx = {
-    rebalancer,
-    router: rebalanceRouter,
-    waqMap,
-    rebalancingIndexes,
-    lastAppliedSeqMap,
-    eventHandlers,
-    requireIndex
-  };
-  const narsil = {
-    async createIndex(name, indexConfig) {
-      guardShutdown();
-      validateIndexName(name);
-      if (indexRegistry.has(name)) {
-        throw new NarsilError(ErrorCodes.INDEX_ALREADY_EXISTS, `Index "${name}" already exists`, { indexName: name });
-      }
-      validateSchema(indexConfig.schema);
-      let resolvedEmbeddingAdapter = null;
-      if (indexConfig.embedding) {
-        resolvedEmbeddingAdapter = validateEmbeddingConfig(indexConfig.embedding, indexConfig.schema, config?.embedding);
-      }
-      if (indexConfig.required && indexConfig.required.length > 0) {
-        validateRequiredFieldsInSchema(indexConfig.required, indexConfig.schema);
-      }
-      const language = getLanguage(indexConfig.language ?? "english");
-      executor.createIndex(name, indexConfig, language);
-      const vectorFieldPaths = getVectorFieldPaths(indexConfig.schema);
-      indexRegistry.set(name, {
-        config: indexConfig,
-        language,
-        embeddingAdapter: resolvedEmbeddingAdapter,
-        vectorFieldPaths
-      });
-      await pluginRegistry.runHook("onIndexCreate", { indexName: name, config: indexConfig });
-    },
-    async dropIndex(name) {
-      guardShutdown();
-      const entry = requireIndex(name);
-      executor.dropIndex(name);
-      indexRegistry.delete(name);
-      await pluginRegistry.runHook("onIndexDrop", { indexName: name, config: entry.config });
-    },
-    listIndexes() {
-      const infos = [];
-      for (const [name, entry] of indexRegistry) {
-        const manager = executor.getManager(name);
-        infos.push({
-          name,
-          documentCount: manager?.countDocuments() ?? 0,
-          partitionCount: manager?.partitionCount ?? 0,
-          language: entry.language.name
-        });
-      }
-      return infos;
-    },
-    getStats(indexName) {
-      guardShutdown();
-      const entry = requireIndex(indexName);
-      const manager = executor.getManager(indexName);
-      const mem = manager?.estimateMemoryBytes() ?? 0;
-      return {
-        documentCount: manager?.countDocuments() ?? 0,
-        partitionCount: manager?.partitionCount ?? 0,
-        memoryBytes: mem,
-        indexSizeBytes: mem,
-        language: entry.language.name,
-        schema: entry.config.schema
-      };
-    },
-    getPartitionStats(indexName) {
-      guardShutdown();
-      requireIndex(indexName);
-      return executor.getManager(indexName)?.getPartitionStats() ?? [];
-    },
-    insert(indexName, document, docId, options) {
-      return insertDocument(mutationCtx, indexName, document, docId, options);
-    },
-    insertBatch(indexName, documents, options) {
-      return insertDocumentBatch(mutationCtx, indexName, documents, options);
-    },
-    remove(indexName, docId) {
-      return removeDocument(mutationCtx, indexName, docId);
-    },
-    removeBatch(indexName, docIds) {
-      return removeDocumentBatch(mutationCtx, indexName, docIds);
-    },
-    update(indexName, docId, document) {
-      return updateDocument(mutationCtx, indexName, docId, document);
-    },
-    updateBatch(indexName, updates) {
-      return updateDocumentBatch(mutationCtx, indexName, updates);
-    },
-    async get(indexName, docId) {
-      guardShutdown();
-      requireIndex(indexName);
-      return executor.execute({ type: "get", indexName, docId, requestId: docId });
-    },
-    async getMultiple(indexName, docIds) {
-      guardShutdown();
-      requireIndex(indexName);
-      const result = /* @__PURE__ */ new Map();
-      for (const docId of docIds) {
-        const doc = await narsil.get(indexName, docId);
-        if (doc !== void 0) result.set(docId, doc);
-      }
-      return result;
-    },
-    async has(indexName, docId) {
-      guardShutdown();
-      requireIndex(indexName);
-      return executor.execute({ type: "has", indexName, docId, requestId: docId });
-    },
-    async countDocuments(indexName) {
-      guardShutdown();
-      requireIndex(indexName);
-      return executor.execute({ type: "count", indexName, requestId: indexName });
-    },
-    async query(indexName, params) {
-      guardShutdown();
-      const entry = requireIndex(indexName);
-      const manager = requireManager(indexName);
-      const resolvedParams = await resolveVectorText(params, entry.embeddingAdapter, abortController.signal);
-      await pluginRegistry.runHook("beforeSearch", { indexName, params: resolvedParams });
-      const workerSearch = orchestrator.isPromoted() ? orchestrator.searchViaWorker.bind(orchestrator) : void 0;
-      const result = await executeQuery(resolvedParams, {
-        manager,
-        language: entry.language,
-        config: entry.config,
-        workerSearch,
-        indexName
-      });
-      try {
-        await pluginRegistry.runHook("afterSearch", {
-          indexName,
-          params: resolvedParams,
-          results: result
-        });
-      } catch (err) {
-        console.warn("afterSearch plugin hook error:", err);
-      }
-      return result;
-    },
-    async preflight(indexName, params) {
-      guardShutdown();
-      const entry = requireIndex(indexName);
-      const manager = requireManager(indexName);
-      const resolvedParams = await resolveVectorText(params, entry.embeddingAdapter, abortController.signal);
-      const workerSearch = orchestrator.isPromoted() ? orchestrator.searchViaWorker.bind(orchestrator) : void 0;
-      return executePreflight(resolvedParams, {
-        manager,
-        language: entry.language,
-        config: entry.config,
-        workerSearch,
-        indexName
-      });
-    },
-    async suggest(indexName, params) {
-      guardShutdown();
-      return executeSuggest(requireManager(indexName), requireIndex(indexName).language, params);
-    },
-    async snapshot(indexName) {
-      guardShutdown();
-      return createSnapshot(requireManager(indexName), requireIndex(indexName));
-    },
-    async restore(indexName, data) {
-      guardShutdown();
-      return restoreFromSnapshot(
-        indexName,
-        data,
-        executor,
-        indexRegistry,
-        getVectorFieldPaths,
-        narsil.dropIndex.bind(narsil),
-        requireManager
-      );
-    },
-    async clear(indexName) {
-      guardShutdown();
-      requireIndex(indexName);
-      await executor.execute({ type: "clear", indexName, requestId: indexName });
-      await orchestrator.replicateToWorkers({ type: "clear", indexName, requestId: `replicate-clear-${indexName}` });
-    },
-    async rebalance(indexName, targetPartitionCount) {
-      guardShutdown();
-      requireIndex(indexName);
-      return executeRebalance(requireManager(indexName), indexName, targetPartitionCount, rebalanceCtx);
-    },
-    async updatePartitionConfig(indexName, partitionConfig) {
-      guardShutdown();
-      const entry = requireIndex(indexName);
-      const manager = requireManager(indexName);
-      if (rebalancingIndexes.has(indexName)) {
-        throw new NarsilError(
-          ErrorCodes.PARTITION_REBALANCING_BACKPRESSURE,
-          `Index "${indexName}" is currently being rebalanced`
-        );
-      }
-      const currentDocCount = manager.countDocuments();
-      const newMaxDocs = partitionConfig.maxDocsPerPartition ?? entry.config.partitions?.maxDocsPerPartition;
-      const newMaxPartitions = partitionConfig.maxPartitions ?? entry.config.partitions?.maxPartitions ?? manager.partitionCount;
-      if (newMaxDocs !== void 0) {
-        const newTotalCapacity = newMaxDocs * newMaxPartitions;
-        if (newTotalCapacity < currentDocCount) {
-          throw new NarsilError(
-            ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
-            `New capacity (${newTotalCapacity}) is less than current document count (${currentDocCount})`,
-            { newTotalCapacity, currentDocCount }
-          );
-        }
-      }
-      if (!entry.config.partitions) entry.config.partitions = {};
-      if (partitionConfig.maxDocsPerPartition !== void 0)
-        entry.config.partitions.maxDocsPerPartition = partitionConfig.maxDocsPerPartition;
-      if (partitionConfig.maxPartitions !== void 0)
-        entry.config.partitions.maxPartitions = partitionConfig.maxPartitions;
-    },
-    getMemoryStats() {
-      const workerStats = orchestrator.getMemoryStats();
-      let mainThreadBytes = 0;
-      for (const [name] of indexRegistry) {
-        const mgr = executor.getManager(name);
-        if (mgr) mainThreadBytes += mgr.estimateMemoryBytes();
-      }
-      return { totalBytes: mainThreadBytes + workerStats.totalBytes, workers: workerStats.workers };
-    },
-    async compactVectors(indexName, fieldName) {
-      guardShutdown();
-      requireIndex(indexName);
-      compactVectors(requireManager(indexName), indexName, fieldName);
-    },
-    async optimizeVectors(indexName, fieldName) {
-      guardShutdown();
-      requireIndex(indexName);
-      await optimizeVectors(requireManager(indexName), indexName, fieldName);
-    },
-    vectorMaintenanceStatus(indexName) {
-      guardShutdown();
-      requireIndex(indexName);
-      return getVectorMaintenanceStatus(requireManager(indexName));
-    },
-    on(event, handler) {
-      const key = event;
-      let handlers = eventHandlers.get(key);
-      if (!handlers) {
-        handlers = /* @__PURE__ */ new Set();
-        eventHandlers.set(key, handlers);
-      }
-      handlers.add(handler);
-    },
-    off(event, handler) {
-      const key = event;
-      const handlers = eventHandlers.get(key);
-      if (handlers) {
-        handlers.delete(handler);
-        if (handlers.size === 0) eventHandlers.delete(key);
-      }
-    },
-    async shutdown() {
-      if (isShutdown) return;
-      isShutdown = true;
-      abortController.abort();
-      for (const [name] of indexRegistry) {
-        const mgr = executor.getManager(name);
-        if (mgr) {
-          for (const [, vecIdx] of mgr.getVectorIndexes()) {
-            vecIdx.dispose();
-          }
-        }
-      }
-      if (flushManager) await flushManager.shutdown();
-      const adaptersToShutdown = /* @__PURE__ */ new Set();
-      for (const [, entry] of indexRegistry) {
-        if (entry.embeddingAdapter?.shutdown) adaptersToShutdown.add(entry.embeddingAdapter);
-      }
-      for (const adapter of adaptersToShutdown) {
-        try {
-          await adapter.shutdown?.();
-        } catch (_) {
-        }
-      }
-      await orchestrator.shutdown();
-      await executor.shutdown();
-      eventHandlers.clear();
-      indexRegistry.clear();
-    }
-  };
-  return narsil;
-}
-
-// src/index.ts
-var VERSION = "0.1.0";
-
-export { VERSION, createNarsil };
+export { VERSION, createNarsil } from './chunk-GQEHCZG7.mjs';
+export { clearNormalizationCache, configureNormalizationCache, getLanguage, getNormalizationCacheSize, registerLanguage, resetNormalizationCache } from './chunk-FS7XLIUS.mjs';
+export { isSimdAvailable } from './chunk-S7RJJMHI.mjs';
+import './chunk-KMMJMDUA.mjs';
+import './chunk-TW6BXTOL.mjs';
+export { ErrorCodes, NarsilError } from './chunk-ALB35PRQ.mjs';
+import './chunk-HRABJLPB.mjs';