@delali/narsil 0.2.3 → 0.2.4-next.43

package/dist/adapters/filesystem.mjs

@@ -1,4 +1,4 @@
-import { NarsilError, ErrorCodes } from '../chunk-GB2IIJJG.mjs';
+import { NarsilError, ErrorCodes } from '../chunk-TLRUUMVE.mjs';
 
 // src/persistence/filesystem.ts
 var cachedFs = null;

package/dist/adapters/indexeddb.mjs

@@ -1,4 +1,4 @@
-import { NarsilError, ErrorCodes } from '../chunk-GB2IIJJG.mjs';
+import { NarsilError, ErrorCodes } from '../chunk-TLRUUMVE.mjs';
 
 // src/persistence/indexeddb.ts
 var DEFAULT_DB_NAME = "narsil";

package/dist/{chunk-MMSWEEZT.mjs → chunk-KEDL6FFZ.mjs}

@@ -1,10 +1,10 @@
 import { ReplicationMessageTypes } from './chunk-JQUL2T6I.mjs';
-import { MAX_INDEX_NAME_LENGTH } from './chunk-WU2UZEVD.mjs';
-import { getNestedValue, getLanguage, extractVectorFieldsFromSchema, createDirectExecutor, createPartitionRouter, clampRowCount, DEFAULT_PAGE_SIZE, validateSchema, validateVectorPromotion, collectQueryTermStats, createPartitionManager, createVectorIndex, flattenSchema, isTextFieldType, requireWithinResultWindow, normalizeSort, sortSignatureOf, requireSortableFields, fanOutQuery, applySorting, applyPagination, resolveProjection, tokenize, decodePageCursor, requireMatchingCursor, encodePageCursor, resolveIndexAnalysis, deserializePayloadV2, deserializePayloadV1, validateRequiredFields, mergePartitionStats, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, createPartitionIndex, fnv1a, createWorkerPool, validateDocument, validateDocumentStrict, createFrozenSegment, detectRuntime, isNodeMainThread, spawnNodeWorker, createSharedFrozenSegment, buildCompactedSegmentPayload, freezeSegmentShared, deserializeMetadata, isCompositePartition, serializeMetadata, kWayMerge } from './chunk-GRWFY2HI.mjs';
+import { MAX_INDEX_NAME_LENGTH } from './chunk-O4Q5JYNK.mjs';
+import { getNestedValue, getLanguage, extractVectorFieldsFromSchema, createDirectExecutor, createPartitionRouter, clampRowCount, DEFAULT_PAGE_SIZE, validateSchema, validateVectorPromotion, collectQueryTermStats, createPartitionManager, createVectorIndex, flattenSchema, isTextFieldType, fnv1aBytes, requireWithinResultWindow, normalizeSort, sortSignatureOf, requireSortableFields, fanOutQuery, applySorting, applyPagination, resolveProjection, countsWithoutScores, fanOutMatchCount, tokenize, decodePageCursor, requireMatchingCursor, encodePageCursor, resolveIndexAnalysis, deserializePayloadV2, deserializePayloadV1, validateRequiredFields, mergePartitionStats, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, createPartitionIndex, fnv1a, createWorkerPool, partitionsIn, validateDocument, validateDocumentStrict, createFrozenSegment, detectRuntime, isNodeMainThread, spawnNodeWorker, createSharedFrozenSegment, buildCompactedSegmentPayload, freezeSegmentShared, deserializeMetadata, isCompositePartition, serializeMetadata, kWayMerge } from './chunk-YGQMKTKG.mjs';
 import { crc32, crc32Init, crc32Update, crc32Final } from './chunk-KMMJMDUA.mjs';
 import { compareCodePoints, compareComparableKeys } from './chunk-BFIH7OV5.mjs';
 import { generateId, createRequestId, isValidWorkerResponse } from './chunk-WTONLDU3.mjs';
-import { ErrorCodes, NarsilError } from './chunk-GB2IIJJG.mjs';
+import { ErrorCodes, NarsilError } from './chunk-TLRUUMVE.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 // src/partitioning/rebalancer.ts
@@ -57,7 +57,7 @@ function createRebalancer() {
         skipClone: true,
         stopWordOverride: manager.analysis.stopWords,
         customTokenizer: manager.analysis.customTokenizer,
-        collectSurfaces: manager.config.surfaceForms === true
+        collectSurfaces: manager.config.surfaceForms !== false
       };
       for (const partition of currentPartitions) {
         const docIds = [...partition.docIds()];
@@ -952,6 +952,9 @@ function writeHeader(header) {
   }
   return buffer;
 }
+function hasNrslMagic(data) {
+  return data.length >= MAGIC_BYTES.length && data[0] === MAGIC_BYTES[0] && data[1] === MAGIC_BYTES[1] && data[2] === MAGIC_BYTES[2] && data[3] === MAGIC_BYTES[3];
+}
 function readHeader(data) {
   if (data.length < HEADER_SIZE) {
     throw new NarsilError(
@@ -987,6 +990,7 @@ function readHeader(data) {
 // src/serialization/envelope.ts
 var CURRENT_ENVELOPE_VERSION = 1;
 var SNAPSHOT_ENVELOPE_VERSION = 2;
+var INDEX_SNAPSHOT_ENVELOPE_VERSION = 3;
 function parseEngineVersion(version) {
   const parts = version.split(".");
   return [parseInt(parts[0] ?? "0", 10), parseInt(parts[1] ?? "0", 10), parseInt(parts[2] ?? "0", 10)];
@@ -1131,6 +1135,19 @@ function concatEnvelopeParts(parts) {
 async function unpackEnvelopeBytes(data) {
   return unpackEnvelope(data, SNAPSHOT_ENVELOPE_VERSION);
 }
+async function packIndexSnapshotEnvelope(payloadBytes) {
+  return packEnvelope(payloadBytes, { checksum: true, envelopeFormatVersion: INDEX_SNAPSHOT_ENVELOPE_VERSION });
+}
+async function unpackIndexSnapshotEnvelope(data) {
+  const { header, payloadBytes } = await unpackEnvelope(data, INDEX_SNAPSHOT_ENVELOPE_VERSION);
+  if (header.envelopeFormatVersion !== INDEX_SNAPSHOT_ENVELOPE_VERSION) {
+    throw new NarsilError(
+      ErrorCodes.ENVELOPE_VERSION_MISMATCH,
+      `Expected an index snapshot envelope of format v${INDEX_SNAPSHOT_ENVELOPE_VERSION}, received format v${header.envelopeFormatVersion}`
+    );
+  }
+  return payloadBytes;
+}
 async function writeMetadataEnvelope(meta, options = {}) {
   const payloadBytes = serializeMetadata(meta);
   return packEnvelope(payloadBytes, options);
@@ -4946,14 +4963,34 @@ async function awaitCompactions(state) {
 var DEFAULT_BACKPRESSURE_LIMIT = 100;
 var DEFAULT_REQUEST_TIMEOUT = 3e4;
 var SHUTDOWN_TIMEOUT = 5e3;
+var CONSECUTIVE_TIMEOUTS_BEFORE_DEATH = 3;
+function errorFromEventLike(event) {
+  if (event instanceof Error) {
+    return event;
+  }
+  if (typeof event === "object" && event !== null) {
+    const detail = event;
+    if (detail.error instanceof Error) {
+      return detail.error;
+    }
+    if (typeof detail.message === "string" && detail.message.length > 0) {
+      return new Error(detail.message);
+    }
+  }
+  return new Error("The worker reported an error event carrying no detail");
+}
 function createWorkerExecutor(worker, config) {
-  const backpressureLimit = DEFAULT_BACKPRESSURE_LIMIT;
-  const requestTimeout = DEFAULT_REQUEST_TIMEOUT;
+  const backpressureLimit = config?.backpressureLimit ?? DEFAULT_BACKPRESSURE_LIMIT;
+  const requestTimeout = config?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
   const pending = /* @__PURE__ */ new Map();
+  let deathError = null;
+  let shutdownRequested = false;
+  let consecutiveTimeouts = 0;
   function processResponse(msg) {
     if (!isValidWorkerResponse(msg)) {
       return;
     }
+    consecutiveTimeouts = 0;
     const response = msg;
     const entry = pending.get(response.requestId);
     if (!entry) {
@@ -4967,15 +5004,36 @@ function createWorkerExecutor(worker, config) {
       entry.resolve(response.data);
     }
   }
+  function handleDeath(cause) {
+    if (deathError !== null) {
+      return;
+    }
+    const message = cause instanceof Error ? cause.message : String(cause);
+    deathError = new NarsilError(ErrorCodes.WORKER_CRASHED, `Worker died: ${message}`);
+    for (const [id, entry] of pending) {
+      clearTimeout(entry.timeoutId);
+      entry.reject(deathError);
+      pending.delete(id);
+    }
+    if (!shutdownRequested) {
+      config?.onDeath?.(cause instanceof Error ? cause : new Error(message));
+    }
+  }
   if (typeof worker.on === "function") {
     worker.on("message", (msg) => processResponse(msg));
+    worker.on("error", (cause) => handleDeath(cause));
+    worker.on("exit", (code) => handleDeath(new Error(`Worker exited with code ${String(code)}`)));
   } else if (typeof worker.addEventListener === "function") {
     worker.addEventListener("message", (event) => {
       const msg = event.data;
       processResponse(msg);
     });
+    worker.addEventListener("error", (event) => handleDeath(errorFromEventLike(event)));
   }
   function execute(action) {
+    if (deathError !== null) {
+      return Promise.reject(deathError);
+    }
     if (pending.size >= backpressureLimit) {
       return Promise.reject(
         new NarsilError(ErrorCodes.WORKER_BUSY, `Backpressure limit of ${backpressureLimit} pending requests reached`)
@@ -4987,6 +5045,10 @@ function createWorkerExecutor(worker, config) {
       const timeoutId = setTimeout(() => {
         pending.delete(requestId);
         reject(new NarsilError(ErrorCodes.WORKER_TIMEOUT, `Request ${requestId} timed out after ${requestTimeout}ms`));
+        consecutiveTimeouts += 1;
+        if (consecutiveTimeouts >= CONSECUTIVE_TIMEOUTS_BEFORE_DEATH) {
+          handleDeath(new Error(`no answer to ${CONSECUTIVE_TIMEOUTS_BEFORE_DEATH} consecutive requests`));
+        }
       }, requestTimeout);
       pending.set(requestId, {
         resolve,
@@ -4997,6 +5059,10 @@ function createWorkerExecutor(worker, config) {
     });
   }
   async function shutdown() {
+    shutdownRequested = true;
+    if (deathError !== null) {
+      return;
+    }
     const requestId = createRequestId();
     const shutdownAction = { type: "shutdown", requestId };
     const shutdownPromise = new Promise((resolve, reject) => {
@@ -5038,15 +5104,15 @@ async function createWorkerFactory(entryPoint) {
   const resolvedEntry = resolveEntryPoint();
   if (runtime.supportsWorkerThreads) {
     const workerThreadsModule = await import('worker_threads');
-    return function nodeFactory(_workerId) {
+    return function nodeFactory(_workerId, onDeath) {
       const instance = new workerThreadsModule.Worker(new URL(resolvedEntry));
-      return createWorkerExecutor(instance);
+      return createWorkerExecutor(instance, { onDeath });
     };
   }
   if (runtime.supportsWebWorkers) {
-    return function webFactory(_workerId) {
+    return function webFactory(_workerId, onDeath) {
       const instance = new Worker(resolvedEntry, { type: "module" });
-      return createWorkerExecutor(instance);
+      return createWorkerExecutor(instance, { onDeath });
     };
   }
   throw new NarsilError(ErrorCodes.WORKER_CRASHED, `No worker support available on runtime "${runtime.runtime}"`);
@@ -5102,7 +5168,13 @@ async function runPromotion(state, reason) {
       return;
     }
     const factory = await createWorkerFactory();
-    const pool = createWorkerPool({ count: state.config?.workers?.count, workerFactory: factory });
+    const pool = createWorkerPool({
+      count: state.config?.workers?.count,
+      workerFactory: factory,
+      onWorkerCrash(workerId, indexNames, error) {
+        state.callbacks?.onWorkerCrash?.(workerId, indexNames, error);
+      }
+    });
     for (const name of promotable) {
       pool.addIndexToAll(name);
     }
@@ -5423,6 +5495,9 @@ function createEngineCore(config) {
       if (handlers) {
         for (const handler of handlers) handler({ workerCount, reason });
       }
+      void Promise.resolve(pluginRegistry.runHook("onWorkerPromote", { workerCount, reason })).catch((err) => {
+        console.warn("onWorkerPromote plugin hook failed:", err instanceof Error ? err.message : String(err));
+      });
     },
     onPromotionFailure(reason, error, retryable) {
       const handlers = eventHandlers.get("workerPromoteFailure");
@@ -5431,6 +5506,14 @@ function createEngineCore(config) {
         return;
       }
       for (const handler of handlers) handler({ reason, error, retryable });
+    },
+    onWorkerCrash(workerId, indexNames, error) {
+      const handlers = eventHandlers.get("workerCrash");
+      if (!handlers || handlers.size === 0) {
+        console.warn(`Worker ${workerId} crashed:`, error);
+        return;
+      }
+      for (const handler of handlers) handler({ workerId, indexNames, error });
     }
   });
   const rebalancer = createRebalancer();
@@ -7389,6 +7472,15 @@ async function executeRebalance(manager, indexName, targetPartitionCount, ctx) {
         }
       }
     });
+    try {
+      await ctx.pluginRegistry.runHook("onPartitionSplit", {
+        indexName,
+        oldPartitionCount: oldCount,
+        newPartitionCount: targetPartitionCount
+      });
+    } catch (hookErr) {
+      console.warn("onPartitionSplit plugin hook failed:", hookErr instanceof Error ? hookErr.message : String(hookErr));
+    }
     await replayQueued(manager, indexName, waq, ctx);
     if (ctx.durabilityManager) {
       await ctx.durabilityManager.persistMetadata(indexName);
@@ -7603,7 +7695,7 @@ async function createSnapshot(manager, entry) {
   const config = entry.config;
   const bm25 = config.bm25;
   const { encode: encode9 } = await import('@msgpack/msgpack');
-  return encode9({
+  const payload = encode9({
     version: 2,
     schema: config.schema,
     language: entry.language.name,
@@ -7633,15 +7725,17 @@ async function createSnapshot(manager, entry) {
     partitions: partitionBuffers,
     vectorIndexes: vectorPayloads
   });
+  return packIndexSnapshotEnvelope(payload);
 }
 async function restoreFromSnapshot(indexName, data, deps) {
   if (!(data instanceof Uint8Array)) {
     throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Snapshot data must be a Uint8Array");
   }
+  const payloadBytes = hasNrslMagic(data) ? await unpackIndexSnapshotEnvelope(data) : data;
   const { decode: decode9 } = await import('@msgpack/msgpack');
   let decoded;
   try {
-    decoded = decode9(data);
+    decoded = decode9(payloadBytes);
   } catch (err) {
     throw new NarsilError(
       ErrorCodes.DOC_VALIDATION_FAILED,
@@ -7836,6 +7930,137 @@ function readProcessMemory() {
   }
 }
 
+// src/search/cursor-binding.ts
+var ABSENT_TAG = 0;
+var NULL_TAG = 1;
+var FALSE_TAG = 2;
+var TRUE_TAG = 3;
+var NUMBER_TAG = 4;
+var STRING_TAG = 5;
+var LIST_TAG = 6;
+var MAP_TAG = 7;
+var encoder = new TextEncoder();
+function ensureCapacity(stream, extra) {
+  if (stream.length + extra <= stream.bytes.length) return;
+  const grown = new Uint8Array(Math.max(stream.bytes.length * 2, stream.length + extra));
+  grown.set(stream.bytes.subarray(0, stream.length));
+  stream.bytes = grown;
+}
+function writeByte(stream, value) {
+  ensureCapacity(stream, 1);
+  stream.bytes[stream.length] = value;
+  stream.length += 1;
+}
+function writeUint32(stream, value) {
+  ensureCapacity(stream, 4);
+  stream.bytes[stream.length] = value >>> 24 & 255;
+  stream.bytes[stream.length + 1] = value >>> 16 & 255;
+  stream.bytes[stream.length + 2] = value >>> 8 & 255;
+  stream.bytes[stream.length + 3] = value & 255;
+  stream.length += 4;
+}
+var numberBytes = new DataView(new ArrayBuffer(8));
+function writeNumber(stream, value) {
+  numberBytes.setFloat64(0, value, false);
+  ensureCapacity(stream, 8);
+  for (let i = 0; i < 8; i++) {
+    stream.bytes[stream.length + i] = numberBytes.getUint8(i);
+  }
+  stream.length += 8;
+}
+function writeString(stream, value) {
+  const encoded = encoder.encode(value);
+  writeUint32(stream, encoded.length);
+  ensureCapacity(stream, encoded.length);
+  stream.bytes.set(encoded, stream.length);
+  stream.length += encoded.length;
+}
+function writeValue(stream, value) {
+  if (value === void 0) {
+    writeByte(stream, ABSENT_TAG);
+    return;
+  }
+  if (value === null) {
+    writeByte(stream, NULL_TAG);
+    return;
+  }
+  if (typeof value === "boolean") {
+    writeByte(stream, value ? TRUE_TAG : FALSE_TAG);
+    return;
+  }
+  if (typeof value === "number") {
+    writeByte(stream, NUMBER_TAG);
+    writeNumber(stream, value);
+    return;
+  }
+  if (typeof value === "string") {
+    writeByte(stream, STRING_TAG);
+    writeString(stream, value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    writeByte(stream, LIST_TAG);
+    writeUint32(stream, value.length);
+    for (const member of value) {
+      writeValue(stream, member ?? null);
+    }
+    return;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort(compareCodePoints);
+  writeByte(stream, MAP_TAG);
+  writeUint32(stream, keys.length);
+  for (const key of keys) {
+    writeByte(stream, STRING_TAG);
+    writeString(stream, key);
+    writeValue(stream, record[key] ?? null);
+  }
+}
+function boundVectorOf(vector) {
+  if (vector === void 0) return void 0;
+  const bound = { ...vector };
+  if (vector.value !== void 0) {
+    bound.value = Array.from(vector.value, Math.fround);
+  }
+  if (vector.text !== void 0) {
+    delete bound.value;
+  }
+  return bound;
+}
+var FILTERS_SLOT = 2;
+var BOUND_SLOT_COUNT = 15;
+function bindingOf(values) {
+  const stream = { bytes: new Uint8Array(256), length: 0 };
+  for (const value of values) {
+    writeValue(stream, value);
+  }
+  return fnv1aBytes(stream.bytes.subarray(0, stream.length)).toString(16).padStart(8, "0");
+}
+function queryBindingOf(params) {
+  return bindingOf([
+    params.term,
+    params.fields,
+    params.filters,
+    params.boost,
+    params.minScore,
+    params.termMatch,
+    params.tolerance,
+    params.prefixLength,
+    params.prefix,
+    params.exact,
+    params.pinned,
+    params.mode,
+    params.hybrid,
+    boundVectorOf(params.vector),
+    params.scoring ?? "local"
+  ]);
+}
+function listBindingOf(filters) {
+  const values = new Array(BOUND_SLOT_COUNT).fill(void 0);
+  values[FILTERS_SLOT] = filters;
+  return bindingOf(values);
+}
+
 // src/engine/list-documents/index.ts
 function clampListLimit(limit) {
   const clamped = Math.max(1, clampLimit(limit));
@@ -7870,7 +8095,7 @@ function collectCandidates(partition, anchor, matches, wanted, out) {
     taken++;
   }
 }
-function pageInIdOrder(partitions, cursor, filtered, limit) {
+function pageInIdOrder(partitions, cursor, filtered, limit, binding) {
   const anchor = cursor === null ? null : cursor.anchor;
   const candidates = [];
   for (let index = 0; index < partitions.length; index++) {
@@ -7885,10 +8110,10 @@ function pageInIdOrder(partitions, cursor, filtered, limit) {
   candidates.sort(compareCodePoints);
   const hasMore = candidates.length > limit;
   const ids = hasMore ? candidates.slice(0, limit) : candidates;
-  const nextCursor = hasMore && ids.length > 0 ? { anchor: ids[ids.length - 1], score: null, sortKey: null, sortSignature: null } : null;
+  const nextCursor = hasMore && ids.length > 0 ? { anchor: ids[ids.length - 1], score: null, sortKey: null, sortSignature: null, binding } : null;
   return { ids, nextCursor };
 }
-function pageInSortOrder(partitions, cursor, filtered, limit, sort, signature, schema) {
+function pageInSortOrder(partitions, cursor, filtered, limit, sort, signature, schema, binding) {
   const normalized = normalizeSort(sort);
   const fields = normalized.map((entry) => entry.field);
   const directions = normalized.map((entry) => entry.direction);
@@ -7911,7 +8136,7 @@ function pageInSortOrder(partitions, cursor, filtered, limit, sort, signature, s
   const hasMore = merged.length > limit;
   const page = hasMore ? merged.slice(0, limit) : merged;
   const last = page[page.length - 1];
-  const nextCursor = hasMore && last !== void 0 ? { anchor: last.id, score: null, sortKey: last.key, sortSignature: signature } : null;
+  const nextCursor = hasMore && last !== void 0 ? { anchor: last.id, score: null, sortKey: last.key, sortSignature: signature, binding } : null;
   return { ids: page.map((entry) => entry.id), nextCursor };
 }
 function countAcrossPartitions(manager, partitionIds, partitions) {
@@ -7930,15 +8155,16 @@ function executeListDocuments(params, context) {
   const limit = clampListLimit(params.limit);
   const signature = sortSignatureOf(params.sort);
   requireSortableFields(params.sort, schema);
+  const binding = listBindingOf(params.filters);
   let cursor = null;
   if (params.cursor !== void 0) {
     cursor = decodePageCursor(params.cursor);
-    requireMatchingCursor(cursor, params.cursor, signature, false);
+    requireMatchingCursor(cursor, params.cursor, signature, false, binding);
   }
   const partitions = context.partitionIds === void 0 ? manager.getAllPartitions() : context.partitionIds.map((partitionId) => manager.partitionAt(partitionId)).filter((partition) => partition !== void 0);
   const filtered = params.filters === void 0 ? null : collectFilterMatches(partitions, params.filters, schema);
   const total = filtered === null ? countAcrossPartitions(manager, context.partitionIds, partitions) : filtered.total;
-  const page = params.sort === void 0 || signature === null ? pageInIdOrder(partitions, cursor, filtered, limit) : pageInSortOrder(partitions, cursor, filtered, limit, params.sort, signature, schema);
+  const page = params.sort === void 0 || signature === null ? pageInIdOrder(partitions, cursor, filtered, limit, binding) : pageInSortOrder(partitions, cursor, filtered, limit, params.sort, signature, schema, binding);
   const projection = resolveProjection(params.document);
   const documents = [];
   for (const docId of page.ids) {
@@ -8006,18 +8232,14 @@ function applyGrouping(hits, group, getDocument) {
     }
     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 ?? 0);
-          }
-        }
-        ;
-        result.reduced = accumulator;
-      } catch (err) {
-        result.reducerError = err instanceof Error ? err.message : String(err);
+      const folded = foldGroupReducer(
+        group.reduce,
+        groupHits.map((hit) => ({ document: getDocument(hit.id), score: hit.score ?? 0 }))
+      );
+      if (folded.reducerError !== void 0) {
+        result.reducerError = folded.reducerError;
+      } else {
+        result.reduced = folded.reduced;
       }
     }
     groups.push(result);
@@ -8030,19 +8252,49 @@ function applyGrouping(hits, group, getDocument) {
     const bId = b.hits.length > 0 ? b.hits[0].id : "";
     return compareCodePoints(aId, bId);
   });
+  if (group.limit !== void 0 && Number.isFinite(group.limit) && group.limit >= 0) {
+    const cap = Math.floor(group.limit);
+    if (groups.length > cap) {
+      groups.length = cap;
+    }
+  }
   return groups;
 }
+function foldGroupReducer(reduce, rows) {
+  try {
+    let accumulator = reduce.initialValue();
+    for (const row of rows) {
+      if (row.document !== void 0) {
+        accumulator = reduce.reducer(accumulator, row.document, row.score);
+      }
+    }
+    return { reduced: accumulator };
+  } catch (err) {
+    return { reducerError: err instanceof Error ? err.message : String(err) };
+  }
+}
 
 // src/search/pinning.ts
+function dedupePinnedEntries(pinned) {
+  const deduped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of pinned) {
+    if (seen.has(entry.docId)) continue;
+    seen.add(entry.docId);
+    deduped.push(entry);
+  }
+  return deduped;
+}
 function applyPinning(hits, pinned, resolveDoc) {
   const result = hits.slice();
-  const pinnedDocIds = new Set(pinned.map((p) => p.docId));
+  const deduped = dedupePinnedEntries(pinned);
+  const pinnedDocIds = new Set(deduped.map((entry) => entry.docId));
   for (let i = result.length - 1; i >= 0; i--) {
     if (pinnedDocIds.has(result[i].id)) {
       result.splice(i, 1);
     }
   }
-  const sorted = pinned.slice().sort((a, b) => a.position - b.position);
+  const sorted = deduped.sort((a, b) => a.position - b.position);
   for (const entry of sorted) {
     const doc = resolveDoc(entry.docId);
     if (!doc) continue;
@@ -8236,17 +8488,7 @@ function applyHighlights(hits, params, language, analysis) {
 
 // src/engine/query/shared.ts
 function partitionsFor(manager, partitionIds) {
-  if (partitionIds === void 0) {
-    return manager.getAllPartitions();
-  }
-  const partitions = [];
-  for (const partitionId of partitionIds) {
-    const partition = manager.partitionAt(partitionId);
-    if (partition !== void 0) {
-      partitions.push(partition);
-    }
-  }
-  return partitions;
+  return partitionsIn(manager, partitionIds);
 }
 function coverageFor(manager, partitionIds) {
   if (partitionIds === void 0) {
@@ -8340,7 +8582,7 @@ function executeSortedQueryPage(params, context, limit, offset, sortSignature) {
   let anchorId = null;
   if (params.searchAfter !== void 0) {
     const decoded = decodePageCursor(params.searchAfter);
-    requireMatchingCursor(decoded, params.searchAfter, sortSignature, true);
+    requireMatchingCursor(decoded, params.searchAfter, sortSignature, true, context.cursorBinding);
     anchorKey = decoded.sortKey;
     anchorId = decoded.anchor;
   }
@@ -8385,7 +8627,13 @@ function executeSortedQueryPage(params, context, limit, offset, sortSignature) {
   const last = page[page.length - 1];
   let cursor;
   if (hasMore && last !== void 0) {
-    cursor = encodePageCursor({ anchor: last.id, score: null, sortKey: last.key, sortSignature });
+    cursor = encodePageCursor({
+      anchor: last.id,
+      score: null,
+      sortKey: last.key,
+      sortSignature,
+      binding: context.cursorBinding
+    });
   }
   return {
     hits: page.map((entry) => ({ id: entry.id, document: void 0 })),
@@ -8671,7 +8919,7 @@ async function executeQuery(params, context) {
     if (params.group) {
       groups = applyGrouping(hits, params.group, (docId) => manager.getRef(docId));
     }
-    if (params.pinned) {
+    if (params.pinned && params.searchAfter === void 0 && context.partitionIds === void 0) {
       hits = applyPinning(hits, params.pinned, (docId) => {
         const doc = manager.getRef(docId);
         if (!doc) return void 0;
@@ -8686,7 +8934,16 @@ async function executeQuery(params, context) {
         sortKeyOf
       };
     }
-    const paged = applyPagination(hits, limit, offset, params.searchAfter, sortContext);
+    const pinnedIds = params.pinned !== void 0 && params.searchAfter === void 0 ? new Set(params.pinned.map((entry) => entry.docId)) : void 0;
+    const paged = applyPagination(
+      hits,
+      limit,
+      offset,
+      context.cursorBinding,
+      params.searchAfter,
+      sortContext,
+      pinnedIds
+    );
     paginated = paged.paginated;
     nextCursor = paged.nextCursor;
     count = fanOutResult.totalMatched;
@@ -8755,6 +9012,11 @@ async function executePreflight(params, context) {
   } else if (isHybridMode && hasGlobalVectorIndex) {
     const result = await executeHybridSearch(params, context, preflightLimit, preflightOffset);
     totalMatched = result.totalMatched;
+  } else if (countsWithoutScores(params)) {
+    totalMatched = fanOutMatchCount(manager, params, language, config.schema, {
+      searchOptions: searchOptionsFor(manager),
+      partitionIds: context.partitionIds
+    });
   } else {
     const scoring = scoringConfigFor(params, context);
     const workerResult = workerSearch ? await workerSearch(indexName, params, broadcastStatsForWorker(params, context, scoring), context.partitionIds) : null;
@@ -8908,7 +9170,8 @@ async function runEngineQuery(core, indexName, params, options) {
     workerSearch,
     indexName,
     broadcastStats: broadcastStatsFor(core, options),
-    partitionIds: options?.partitionIds
+    partitionIds: options?.partitionIds,
+    cursorBinding: queryBindingOf(params)
   });
   try {
     await core.pluginRegistry.runHook("afterSearch", {
@@ -8942,7 +9205,8 @@ async function runEnginePreflight(core, indexName, params, options) {
     workerSearch,
     indexName,
     broadcastStats: broadcastStatsFor(core, options),
-    partitionIds: options?.partitionIds
+    partitionIds: options?.partitionIds,
+    cursorBinding: queryBindingOf(params)
   });
   if (core.analysisRebuild.isStale(indexName)) {
     result.analysisStale = true;
@@ -9253,4 +9517,4 @@ async function createNarsil(config) {
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, VERSION, WIRE_BATCH_BUDGET, applyDeleteEntry, applyIndexEntry, chunkByBudget, clampLimit, computeEntryChecksum, createAckMessage, createDurableDirectory, createEngineCore, createEngineIndex, createEntryBatchMessage, createEntryMessage, createForwardBatchMessage, createForwardBatchResultMessage, createForwardMessage, createInsyncAddMessage, createInsyncConfirmMessage, createInsyncRemoveMessage, createNarsil, createNarsilFromCore, now, runEngineListDocuments, runEnginePreflight, runEngineQuery, runEngineQueryStats, runEngineSuggest, validateAckPayload, validateEntryBatchPayload, validateEntryPayload, validateForwardBatchPayload, validateForwardBatchResultPayload, validateInsyncConfirmPayload, validateReplicationEntry, writeSegmentedCheckpoint };
+export { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, VERSION, WIRE_BATCH_BUDGET, applyDeleteEntry, applyIndexEntry, chunkByBudget, clampLimit, computeEntryChecksum, createAckMessage, createDurableDirectory, createEngineCore, createEngineIndex, createEntryBatchMessage, createEntryMessage, createForwardBatchMessage, createForwardBatchResultMessage, createForwardMessage, createInsyncAddMessage, createInsyncConfirmMessage, createInsyncRemoveMessage, createNarsil, createNarsilFromCore, dedupePinnedEntries, foldGroupReducer, listBindingOf, now, queryBindingOf, runEngineListDocuments, runEnginePreflight, runEngineQuery, runEngineQueryStats, runEngineSuggest, validateAckPayload, validateEntryBatchPayload, validateEntryPayload, validateForwardBatchPayload, validateForwardBatchResultPayload, validateInsyncConfirmPayload, validateReplicationEntry, writeSegmentedCheckpoint };

package/dist/{chunk-WU2UZEVD.mjs → chunk-O4Q5JYNK.mjs}

@@ -1,4 +1,4 @@
-import { NarsilError, ErrorCodes } from './chunk-GB2IIJJG.mjs';
+import { NarsilError, ErrorCodes } from './chunk-TLRUUMVE.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 var INDEX_CONFIG_PREFIX = "_narsil/index/";

package/dist/{chunk-GB2IIJJG.mjs → chunk-TLRUUMVE.mjs}

@@ -1,7 +1,6 @@
 // src/errors.ts
 var ErrorCodes = {
   SCHEMA_INVALID_TYPE: "SCHEMA_INVALID_TYPE",
-  SCHEMA_MISSING_FIELD: "SCHEMA_MISSING_FIELD",
   SCHEMA_DEPTH_EXCEEDED: "SCHEMA_DEPTH_EXCEEDED",
   SCHEMA_INVALID_VECTOR_DIMENSION: "SCHEMA_INVALID_VECTOR_DIMENSION",
   SCHEMA_INVALID_GEOPOINT: "SCHEMA_INVALID_GEOPOINT",
@@ -23,7 +22,6 @@ var ErrorCodes = {
   PERSISTENCE_WAL_CORRUPT: "PERSISTENCE_WAL_CORRUPT",
   PERSISTENCE_FSYNC_FAILED: "PERSISTENCE_FSYNC_FAILED",
   SEARCH_INVALID_FIELD: "SEARCH_INVALID_FIELD",
-  SEARCH_INVALID_VECTOR_SIZE: "SEARCH_INVALID_VECTOR_SIZE",
   VECTOR_DIMENSION_MISMATCH: "VECTOR_DIMENSION_MISMATCH",
   SEARCH_INVALID_FILTER: "SEARCH_INVALID_FILTER",
   SEARCH_INVALID_MODE: "SEARCH_INVALID_MODE",
@@ -47,8 +45,6 @@ var ErrorCodes = {
   ALLOCATION_NO_DATA_NODES: "ALLOCATION_NO_DATA_NODES",
   ALLOCATION_INVALID_CONFIG: "ALLOCATION_INVALID_CONFIG",
   ALLOCATION_FAILED: "ALLOCATION_FAILED",
-  CONTROLLER_LEASE_LOST: "CONTROLLER_LEASE_LOST",
-  CONTROLLER_NOT_ACTIVE: "CONTROLLER_NOT_ACTIVE",
   CONTROLLER_METADATA_INVALID: "CONTROLLER_METADATA_INVALID",
   NODE_BOOTSTRAP_FAILED: "NODE_BOOTSTRAP_FAILED",
   NODE_ALREADY_JOINED: "NODE_ALREADY_JOINED",
@@ -104,6 +100,7 @@ var ServerErrorCodes = {
   TASK_NOT_FOUND: "TASK_NOT_FOUND",
   TASK_NOT_CANCELLABLE: "TASK_NOT_CANCELLABLE",
   TASK_OWNED_BY_ANOTHER_INSTANCE: "TASK_OWNED_BY_ANOTHER_INSTANCE",
+  TASK_INTERRUPTED: "TASK_INTERRUPTED",
   TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS",
   HOOK_ERROR: "HOOK_ERROR",
   INTERNAL_ERROR: "INTERNAL_ERROR"