@delali/narsil 0.3.1-next.71 → 0.3.1-next.73

package/dist/{chunk-P4DSQ6M4.mjs → chunk-ZULSEZCE.mjs}

@@ -1,9 +1,8 @@
-import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN, MAX_DOC_ID_LENGTH, DEFAULT_LIMIT, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, ABSOLUTE_WINDOWS_PATH_PATTERN, MODULE_URL_SCHEME_PATTERN, DEFAULT_OFFSET } from './chunk-GIVAGD3Q.mjs';
-import { clampRowCount, sortSignatureOf, requireSortableFields, decodePageCursor, requireMatchingCursor, resolveProjection, encodePageCursor, requireWithinResultWindow, normalizeSort, fanOutQuery, sortModesOf, applySorting, applyPagination, projectionKeepsField, countsWithoutScores, fanOutMatchCount, tokenize, fnv1aBytes, requireValidFilter, everyValueFacetConfig, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, partitionsIn, undeclaredFieldOnStrictIndex, fuzzyTermMatches } from './chunk-LMO5TJUS.mjs';
-import { MIN_PATTERN_VALUE_LIMIT, MAX_PATTERN_VALUE_LIMIT, DEFAULT_MAX_PER_GROUP, flattenSchema, DEFAULT_LINEAR_ALPHA, MIN_LINEAR_ALPHA, MAX_LINEAR_ALPHA, DEFAULT_RANK_CONSTANT, MIN_RANK_CONSTANT, DEFAULT_FUZZY_PREFIX_LENGTH, RESULT_WINDOW, isWordIndexedFieldType, isGeopointOrVectorType, MAX_TOLERANCE, MAX_PREFIX_LENGTH } from './chunk-653BNMAF.mjs';
+import { clampRowCount, sortSignatureOf, requireSortableFields, decodePageCursor, requireMatchingCursor, resolveProjection, encodePageCursor, requireWithinResultWindow, normalizeSort, fanOutQuery, sortModesOf, applySorting, applyPagination, projectionKeepsField, countsWithoutScores, fanOutMatchCount, tokenize, fnv1aBytes, requireValidFilter, createPatternWorkMeter, everyValueFacetConfig, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, partitionsIn, undeclaredFieldOnStrictIndex, fuzzyTermMatches } from './chunk-3YKWSO54.mjs';
+import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN, MAX_DOC_ID_LENGTH, MIN_PATTERN_VALUE_LIMIT, MAX_PATTERN_VALUE_LIMIT, DEFAULT_LIMIT, DEFAULT_MAX_PER_GROUP, flattenSchema, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, ABSOLUTE_WINDOWS_PATH_PATTERN, MODULE_URL_SCHEME_PATTERN, DEFAULT_LINEAR_ALPHA, MIN_LINEAR_ALPHA, MAX_LINEAR_ALPHA, DEFAULT_RANK_CONSTANT, MIN_RANK_CONSTANT, DEFAULT_OFFSET, DEFAULT_FUZZY_PREFIX_LENGTH, RESULT_WINDOW, isWordIndexedFieldType, isGeopointOrVectorType, MAX_TOLERANCE, MAX_PREFIX_LENGTH } from './chunk-AK3BLGCI.mjs';
 import { MIN_OVERSAMPLE } from './chunk-ZJ4CSAB2.mjs';
-import { compareCodePoints, compareComparableKeys } from './chunk-OI42GWLR.mjs';
-import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
+import { holdsUnpairedSurrogate, compareCodePoints, compareComparableKeys } from './chunk-LJYTW7GT.mjs';
+import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 
 // src/search/cursor-binding.ts
 var ABSENT_TAG = 0;
@@ -225,6 +224,9 @@ function requireValidTypoTolerance(params) {
 }
 
 // src/engine/query/shared.ts
+function withPatternWork(context) {
+  return { ...context, patternWork: createPatternWorkMeter(context.patternWorkCap) };
+}
 function partitionsFor(manager, partitionIds) {
   return partitionsIn(manager, partitionIds);
 }
@@ -271,18 +273,19 @@ function broadcastStatsForWorker(params, context, scoring) {
   }
   return pruneStatsToQueryTerms(scoring.globalStats, term, context.language, context.manager.analysis);
 }
-function searchOptionsFor(manager) {
+function searchOptionsFor(manager, patternWork) {
   return {
     bm25Params: manager.config.bm25,
     stopWords: manager.analysis.stopWords,
-    customTokenizer: manager.analysis.customTokenizer
+    customTokenizer: manager.analysis.customTokenizer,
+    patternWork
   };
 }
-function collectFilterDocIds(manager, params, schema, partitionIds) {
+function collectFilterDocIds(manager, params, schema, partitionIds, patternWork) {
   const filterDocIds = /* @__PURE__ */ new Set();
   if (!params.filters) return filterDocIds;
   for (const partition of partitionsFor(manager, partitionIds)) {
-    const partitionFiltered = partition.applyFilters(params.filters, schema);
+    const partitionFiltered = partition.applyFilters(params.filters, schema, patternWork);
     for (const docId of partitionFiltered) {
       filterDocIds.add(docId);
     }
@@ -317,11 +320,11 @@ function requireValidQueryOptions(params, config) {
   const strict = config.strict === true;
   requireValidTypoTolerance(params);
   requireSortableFields(params.sort, config.schema, strict);
-  requireValidQueryFilter(params.filters, config.schema, strict);
+  requireValidQueryFilter(params.filters, config.schema);
   requireUsableQueryFields(params, config.schema, strict);
 }
-function requireValidQueryFilter(filters, schema, strict = false) {
-  if (filters !== void 0) requireValidFilter(filters, flattenSchema(schema), strict);
+function requireValidQueryFilter(filters, schema) {
+  if (filters !== void 0) requireValidFilter(filters, flattenSchema(schema));
 }
 function requireVectorSearchable(params, context, needsVector) {
   if (!needsVector) return;
@@ -395,6 +398,13 @@ function validateDocId(docId) {
   if (docId.includes("\0")) {
     throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Document ID must not contain null bytes", { docId });
   }
+  if (holdsUnpairedSurrogate(docId)) {
+    throw new NarsilError(
+      ErrorCodes.DOC_VALIDATION_FAILED,
+      "Document ID holds an unpaired surrogate, the half of a character such as an emoji whose other half is missing, so the engine cannot store it as UTF-8",
+      { docId }
+    );
+  }
 }
 function validatePartitionConfig(partitions) {
   const { maxDocsPerPartition, maxPartitions, watermark } = partitions;
@@ -493,8 +503,9 @@ function firstIdAfter(sorted, anchor) {
   }
   return low;
 }
-function collectFilterMatches(partitions, filters, schema) {
-  const perPartition = partitions.map((partition) => partition.filterMatches(filters, schema));
+function collectFilterMatches(partitions, filters, schema, patternWorkCap) {
+  const meter = createPatternWorkMeter(patternWorkCap);
+  const perPartition = partitions.map((partition) => partition.filterMatches(filters, schema, meter));
   let total = 0;
   for (const matches of perPartition) total += matches.count;
   return { matchesFor: (partitionIndex) => perPartition[partitionIndex] ?? null, total };
@@ -572,7 +583,7 @@ function executeListDocuments(params, context) {
   const limit = clampListLimit(params.limit);
   const signature = sortSignatureOf(params.sort);
   requireSortableFields(params.sort, schema, context.strict === true);
-  requireValidQueryFilter(params.filters, schema, context.strict === true);
+  requireValidQueryFilter(params.filters, schema);
   const binding = listBindingOf(params.filters);
   let cursor = null;
   if (params.cursor !== void 0) {
@@ -580,7 +591,7 @@ function executeListDocuments(params, context) {
     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 filtered = params.filters === void 0 ? null : collectFilterMatches(partitions, params.filters, schema, context.patternWorkCap);
   const total = filtered === null ? countAcrossPartitions(manager, context.partitionIds, partitions) : filtered.total;
   const page = params.sort === void 0 || signature === null ? pageInIdOrder(partitions, cursor, filtered, limit, binding) : pageInSortOrder(partitions, cursor, filtered, limit, params.sort, signature, schema, binding);
   const projection = resolveProjection(params.document);
@@ -947,7 +958,7 @@ function executeSortedQueryPage(params, context, limit, offset, sortSignature) {
   const flatSchema = flattenSchema(schema);
   const fieldTypes = fields.map((field) => flatSchema[field]);
   const modes = sortModesOf(normalized);
-  const options = searchOptionsFor(manager);
+  const options = searchOptionsFor(manager, context.patternWork);
   const partitions = partitionsFor(manager, context.partitionIds);
   const partitionLimit = offset + limit + 1;
   const merged = [];
@@ -1148,7 +1159,7 @@ async function executeVectorSearch(params, context, limit, offset, cursorDepth =
   let filterDocIds;
   let filterPartitions;
   if (params.filters) {
-    filterDocIds = collectFilterDocIds(manager, params, config.schema, partitionIds);
+    filterDocIds = collectFilterDocIds(manager, params, config.schema, partitionIds, context.patternWork);
     if (filterDocIds.size === 0) {
       return { scored: [], totalMatched: 0 };
     }
@@ -1176,11 +1187,19 @@ async function textLeg(textOnlyParams, context) {
       indexName,
       textOnlyParams,
       broadcastStatsForWorker(textOnlyParams, context, scoring),
-      context.partitionIds
+      context.partitionIds,
+      context.patternWork
     );
     if (viaWorker) return viaWorker;
   }
-  return fanOutQuery(manager, textOnlyParams, language, config.schema, scoring, searchOptionsFor(manager));
+  return fanOutQuery(
+    manager,
+    textOnlyParams,
+    language,
+    config.schema,
+    scoring,
+    searchOptionsFor(manager, context.patternWork)
+  );
 }
 async function vectorLeg(vectorConfig, queryVector, context, filterDocIds, k) {
   const { manager } = context;
@@ -1206,7 +1225,7 @@ async function executeHybridSearch(params, context, limit, offset, cursorDepth =
   const fusion = resolveHybridFusion(params.hybrid);
   let filterDocIds;
   if (params.filters) {
-    filterDocIds = collectFilterDocIds(manager, params, config.schema, context.partitionIds);
+    filterDocIds = collectFilterDocIds(manager, params, config.schema, context.partitionIds, context.patternWork);
     if (filterDocIds.size === 0) {
       return { scored: [], totalMatched: 0 };
     }
@@ -1250,7 +1269,8 @@ function requireCursorDepth(cursor, signature, binding) {
   requireMatchingCursor(decoded, cursor, signature, true, binding);
   return decoded.depth ?? 0;
 }
-async function executeQuery(params, context) {
+async function executeQuery(params, callerContext) {
+  const context = withPatternWork(callerContext);
   const { manager, language, config, workerSearch, indexName } = context;
   const startTime = now();
   const limit = clampLimit(params.limit);
@@ -1296,11 +1316,24 @@ async function executeQuery(params, context) {
       fanOutResult = await executeHybridSearch(params, context, limit, offset, depth);
     } else {
       const scoring = scoringConfigFor(params, context);
-      const workerResult = workerSearch ? await workerSearch(indexName, params, broadcastStatsForWorker(params, context, scoring), context.partitionIds) : null;
+      const workerResult = workerSearch ? await workerSearch(
+        indexName,
+        params,
+        broadcastStatsForWorker(params, context, scoring),
+        context.partitionIds,
+        context.patternWork
+      ) : null;
       if (workerResult) {
         fanOutResult = workerResult;
       } else {
-        fanOutResult = await fanOutQuery(manager, params, language, config.schema, scoring, searchOptionsFor(manager));
+        fanOutResult = await fanOutQuery(
+          manager,
+          params,
+          language,
+          config.schema,
+          scoring,
+          searchOptionsFor(manager, context.patternWork)
+        );
       }
     }
     const needsFullHits = params.sort !== void 0 || params.group !== void 0 || params.pinned !== void 0 || params.searchAfter !== void 0;
@@ -1420,7 +1453,8 @@ async function executeQuery(params, context) {
     coverage: coverageFor(manager, context.partitionIds)
   };
 }
-async function executePreflight(params, context) {
+async function executePreflight(params, callerContext) {
+  const context = withPatternWork(callerContext);
   const { manager, language, config, workerSearch, indexName } = context;
   const startTime = now();
   requireKnownMode(params);
@@ -1446,12 +1480,18 @@ async function executePreflight(params, context) {
     countExact = result.matchedExact !== false;
   } else if (countsWithoutScores(params)) {
     totalMatched = fanOutMatchCount(manager, params, language, config.schema, {
-      searchOptions: searchOptionsFor(manager),
+      searchOptions: searchOptionsFor(manager, context.patternWork),
       partitionIds: context.partitionIds
     });
   } else {
     const scoring = scoringConfigFor(params, context);
-    const workerResult = workerSearch ? await workerSearch(indexName, params, broadcastStatsForWorker(params, context, scoring), context.partitionIds) : null;
+    const workerResult = workerSearch ? await workerSearch(
+      indexName,
+      params,
+      broadcastStatsForWorker(params, context, scoring),
+      context.partitionIds,
+      context.patternWork
+    ) : null;
     if (workerResult) {
       totalMatched = workerResult.totalMatched;
     } else {
@@ -1461,7 +1501,7 @@ async function executePreflight(params, context) {
         language,
         config.schema,
         scoring,
-        searchOptionsFor(manager)
+        searchOptionsFor(manager, context.patternWork)
       );
       totalMatched = fanOutResult.totalMatched;
     }

package/dist/{client-COek5GXK.d.ts → client-D698E5ge.d.ts}

@@ -1,6 +1,6 @@
-import { P as PartitionConfig, A as AnyDocument, a as InsertOptions, W as WriteOptions } from './schema-Bgzr4g7b.js';
-import { V as VectorMaintenanceResult, B as BatchResult, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, P as PartitionStatsResult, Q as QueryParams, e as QueryResult, h as PreflightResult, j as SuggestParams, k as SuggestResult } from './memory-C7UMCMH3.js';
-import { e as TaskRecord, M as MemoryStatsResponse, b as ImportResult, H as HttpIndexConfig, c as TaskListQuery, T as TaskListPage } from './tasks-BZt_zes6.js';
+import { P as PartitionConfig, A as AnyDocument, a as InsertOptions, W as WriteOptions } from './schema-BBOCdhND.js';
+import { V as VectorMaintenanceResult, B as BatchResult, L as ListParams, h as ListResult, I as IndexInfo, g as IndexStats, P as PartitionStatsResult, Q as QueryParams, e as QueryResult, j as PreflightResult, k as SuggestParams, l as SuggestResult } from './memory-B4jMmygw.js';
+import { e as TaskRecord, M as MemoryStatsResponse, b as ImportResult, H as HttpIndexConfig, c as TaskListQuery, T as TaskListPage } from './tasks-DpgCpW1x.js';
 
 /**
  * This is the `fetch` implementation the client sends every request through.
@@ -74,14 +74,15 @@ interface RequestOptions {
 }
 
 /**
- * These methods run the operations that maintain an index: checkpoints,
- * snapshots, vector maintenance, partitioning, and analysis rebuilds.
+ * These methods carry out the operations that maintain an index: checkpoints,
+ * snapshots, document exports, vector maintenance, partitioning, and analysis
+ * rebuilds.
  *
- * Four of them can run for minutes, so each answers with a {@link TaskRecord}
- * while the work carries on, and you follow it with
- * {@link TaskOperations.waitForTask}. The {@link Narsil} methods they mirror
- * return nothing and finish before they resolve, which is the one place this
- * client parts from the engine.
+ * Five of them can take minutes, so each answers with a {@link TaskRecord}
+ * while the work continues. Follow that task with
+ * {@link TaskOperations.waitForTask}. The {@link Narsil} methods that they
+ * mirror finish their work before they resolve, which is the one place where
+ * this client differs from the engine.
  *
  * @public
  */
@@ -96,35 +97,85 @@ interface AdminOperations {
      */
     checkpoint(indexName: string, options?: RequestOptions): Promise<void>;
     /**
-     * Downloads one index as a portable `.nrsl` file, which any Narsil
-     * implementation can read back.
+     * Returns a stream of an index's snapshot archive. Any implementation of
+     * the Narsil format can restore the archive.
      *
-     * The whole index crosses the network, so this call sets no deadline of its
-     * own and waits for as long as the download takes until
-     * {@link NarsilClientOptions.timeoutMs} or a per-call `timeoutMs` sets one.
+     * The download takes longer as the index grows, so this method sets no
+     * deadline of its own. It waits until the download ends, unless
+     * {@link NarsilClientOptions.timeoutMs} or a per-call `timeoutMs` sets a
+     * deadline.
      *
-     * @param indexName - This names the index to serialise.
+     * @param indexName - This names the index to stream.
      * @param options - This sets the signal, the deadline, and the headers for
      * this request.
-     * @returns The bytes make up the file.
+     * @returns The stream holds the archive's bytes in the order that the server
+     * sends them.
      */
-    snapshot(indexName: string, options?: RequestOptions): Promise<Uint8Array>;
+    snapshot(indexName: string, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
     /**
-     * Replaces an index with the contents of a `.nrsl` file, dropping whatever
-     * the index held.
+     * Uploads a snapshot archive and replaces the named index with the
+     * archive's contents. The method also accepts the single `.nrsl` file that
+     * `snapshot` returned in release 0.3.
      *
-     * The load runs as a task, so this resolves once the server has read the
-     * bytes, and the index comes back afterwards.
+     * The server writes the upload to a temporary file and restores the index
+     * in a task. This method therefore resolves once the server holds the whole
+     * upload, and the task's status changes to `succeeded` once the restored
+     * index is ready.
      *
      * @param indexName - This names the index to replace.
-     * @param data - These are the file's bytes.
+     * @param data - This is the archive, as one byte array or a stream of bytes.
      * @param options - This sets the signal, the deadline, and the headers for
      * this request.
      * @returns The record is the task to follow.
-     * @throws A `NarsilError` with `DOC_VALIDATION_FAILED` or an `ENVELOPE_`
-     * code, reported on the task, when the bytes hold no readable snapshot.
+     * @throws A `NarsilError` with `PAYLOAD_TOO_LARGE` when the upload passes
+     * the server's `maxRestoreBytes` limit, and with `EMPTY_BODY` for an empty
+     * upload. The task reports `PERSISTENCE_LOAD_FAILED`,
+     * `PERSISTENCE_CRC_MISMATCH`, `ENVELOPE_VERSION_MISMATCH`, or
+     * `CONFIG_INVALID` in its `error` when a check of the archive fails.
      */
-    restore(indexName: string, data: Uint8Array, options?: RequestOptions): Promise<TaskRecord>;
+    restore(indexName: string, data: Uint8Array | ReadableStream<Uint8Array>, options?: RequestOptions): Promise<TaskRecord>;
+    /**
+     * Returns a stream of an index's document export. The export is JSON Lines
+     * text, with the index configuration on the first line and one document on
+     * each later line. Pass the export to
+     * {@link AdminOperations.importDocumentExport} to load it into a server of
+     * this release or a later one.
+     *
+     * The download takes longer as the index grows, so this method sets no
+     * deadline of its own. It waits until the download ends, unless
+     * {@link NarsilClientOptions.timeoutMs} or a per-call `timeoutMs` sets a
+     * deadline.
+     *
+     * @param indexName - This names the index to export.
+     * @param options - This sets the signal, the deadline, and the headers for
+     * this request.
+     * @returns The stream holds the export's UTF-8 bytes in the order that the
+     * server sends them.
+     */
+    exportDocuments(indexName: string, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
+    /**
+     * Uploads a document export and imports it into an index in a task. Where
+     * the name is free, the engine creates the index from the export's
+     * configuration. The engine replaces each document whose ID the index
+     * already contains.
+     *
+     * The server writes the upload to a temporary file before the task starts,
+     * so this method resolves once the server holds the whole upload. When the
+     * task finishes, its result holds the number of imported documents and the
+     * refused lines.
+     *
+     * @param indexName - This names the index that receives the documents.
+     * @param data - This is the export, as one byte array or a stream of bytes.
+     * @param options - This sets the signal, the deadline, and the headers for
+     * this request.
+     * @returns The record is the task to follow.
+     * @throws A `NarsilError` with `PAYLOAD_TOO_LARGE` when the upload passes
+     * the server's `maxRestoreBytes` limit, and with `EMPTY_BODY` for an empty
+     * upload. The task reports `CONFIG_INVALID` in its `error` when the first
+     * line is anything other than an export header, or when the named index
+     * exists with a different schema.
+     */
+    importDocumentExport(indexName: string, data: Uint8Array | ReadableStream<Uint8Array>, options?: RequestOptions): Promise<TaskRecord>;
     /**
      * Reports the state of each vector field, and what maintenance would cost.
      *

package/dist/client.d.ts

@@ -1,10 +1,10 @@
-export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-C7UMCMH3.js';
-export { A as ASYNC_IMPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-Dt-7B4Wz.js';
-export { C as CapabilitiesResponse, a as CreateIndexEmbedding, H as HttpIndexConfig, I as ImportError, b as ImportResult, M as MemoryStatsResponse, T as TaskListPage, c as TaskListQuery, d as TaskProgress, e as TaskRecord, f as TaskStatus, g as TaskType } from './tasks-BZt_zes6.js';
-export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-COek5GXK.js';
-import './schema-Bgzr4g7b.js';
+export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-B4jMmygw.js';
+export { A as ASYNC_IMPORT_CAPABILITY, D as DOCUMENT_EXPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-CYeAWYxQ.js';
+export { C as CapabilitiesResponse, a as CreateIndexEmbedding, H as HttpIndexConfig, I as ImportError, b as ImportResult, M as MemoryStatsResponse, T as TaskListPage, c as TaskListQuery, d as TaskProgress, e as TaskRecord, f as TaskStatus, g as TaskType } from './tasks-DpgCpW1x.js';
+export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-D698E5ge.js';
+import './schema-BBOCdhND.js';
 import './adapters-79OIa4xm.js';
-import './config-rBpbgTw8.js';
-import './config-Dfanyqqt.js';
-import './types-gOUqhs2F.js';
-import './types-D5OwhtsQ.js';
+import './config-Bv8etwUZ.js';
+import './config-QXU3HMpq.js';
+import './types-BiUmaiWT.js';
+import './types-Cb9kiY5P.js';

package/dist/client.mjs

@@ -31,6 +31,7 @@ var ErrorCodes = {
   SEARCH_INVALID_MODE: "SEARCH_INVALID_MODE",
   SEARCH_INVALID_CURSOR: "SEARCH_INVALID_CURSOR",
   SEARCH_RESULT_WINDOW_EXCEEDED: "SEARCH_RESULT_WINDOW_EXCEEDED",
+  SEARCH_WORK_CAP_EXCEEDED: "SEARCH_WORK_CAP_EXCEEDED",
   LANGUAGE_NOT_SUPPORTED: "LANGUAGE_NOT_SUPPORTED",
   ENVELOPE_VERSION_MISMATCH: "ENVELOPE_VERSION_MISMATCH",
   ENVELOPE_INVALID_MAGIC: "ENVELOPE_INVALID_MAGIC",
@@ -71,7 +72,6 @@ var ErrorCodes = {
   SNAPSHOT_SYNC_UNAUTHORIZED: "SNAPSHOT_SYNC_UNAUTHORIZED",
   SNAPSHOT_SYNC_REQUEST_INVALID: "SNAPSHOT_SYNC_REQUEST_INVALID",
   SNAPSHOT_SYNC_INDEX_NOT_FOUND: "SNAPSHOT_SYNC_INDEX_NOT_FOUND",
-  SNAPSHOT_SYNC_TOO_LARGE: "SNAPSHOT_SYNC_TOO_LARGE",
   SNAPSHOT_SYNC_CAPACITY_EXHAUSTED: "SNAPSHOT_SYNC_CAPACITY_EXHAUSTED",
   SNAPSHOT_SYNC_SNAPSHOT_FAILED: "SNAPSHOT_SYNC_SNAPSHOT_FAILED",
   SNAPSHOT_SYNC_DECODE_FAILED: "SNAPSHOT_SYNC_DECODE_FAILED",
@@ -154,12 +154,14 @@ var TASK_CANCEL_CAPABILITY = "tasks.cancel";
 var TASK_FILTER_CAPABILITY = "tasks.filter";
 var REBUILD_ANALYSIS_CAPABILITY = "indexes.rebuildAnalysis";
 var INDEX_LIFECYCLE_CAPABILITY = "indexes.lifecycle";
+var DOCUMENT_EXPORT_CAPABILITY = "indexes.documentExport";
 var SERVER_CAPABILITIES = [
   ASYNC_IMPORT_CAPABILITY,
   TASK_CANCEL_CAPABILITY,
   TASK_FILTER_CAPABILITY,
   REBUILD_ANALYSIS_CAPABILITY,
-  INDEX_LIFECYCLE_CAPABILITY
+  INDEX_LIFECYCLE_CAPABILITY,
+  DOCUMENT_EXPORT_CAPABILITY
 ];
 
 // src/json-encoding.ts
@@ -240,10 +242,9 @@ function createAdminOperations(transport) {
       await transport.json({ method: "POST", path: `${indexPath(indexName)}/_checkpoint`, options });
     },
     snapshot(indexName, options) {
-      return transport.binary({
+      return transport.stream({
         method: "GET",
         path: `${indexPath(indexName)}/snapshot`,
-        binaryAnswer: true,
         defaultTimeoutMs: NO_TIMEOUT,
         options
       });
@@ -260,6 +261,26 @@ function createAdminOperations(transport) {
       });
       return readBody(payload, path);
     },
+    exportDocuments(indexName, options) {
+      return transport.stream({
+        method: "GET",
+        path: `${indexPath(indexName)}/export`,
+        defaultTimeoutMs: NO_TIMEOUT,
+        options
+      });
+    },
+    async importDocumentExport(indexName, data, options) {
+      const path = `${indexPath(indexName)}/import`;
+      const payload = await transport.json({
+        method: "POST",
+        path,
+        body: data,
+        contentType: "application/x-ndjson",
+        defaultTimeoutMs: NO_TIMEOUT,
+        options
+      });
+      return readBody(payload, path);
+    },
     async vectorMaintenanceStatus(indexName, options) {
       const path = `${indexPath(indexName)}/vector-maintenance`;
       const payload = await transport.json({ method: "GET", path, options });
@@ -516,20 +537,14 @@ async function readStreamCapped(stream, limitBytes) {
   }
   return body;
 }
-async function readAnswer(response, limitBytes, wantsBytes) {
+async function readAnswer(response, limitBytes) {
   const stream = response.body;
   if (limitBytes > 0 && stream !== null && stream !== void 0) {
-    const body = await readStreamCapped(stream, limitBytes);
-    return wantsBytes ? { text: "", bytes: body } : { text: new TextDecoder().decode(body), bytes: null };
-  }
-  if (wantsBytes) {
-    const bytes = new Uint8Array(await response.arrayBuffer());
-    if (limitBytes > 0 && bytes.byteLength > limitBytes) throw new ResponseTooLargeError(limitBytes);
-    return { text: "", bytes };
+    return new TextDecoder().decode(await readStreamCapped(stream, limitBytes));
   }
   const text = await response.text();
   if (limitBytes > 0 && text.length > limitBytes) throw new ResponseTooLargeError(limitBytes);
-  return { text, bytes: null };
+  return text;
 }
 function invalidResponse(message, details) {
   return new NarsilError(ClientErrorCodes.CLIENT_INVALID_RESPONSE, message, details);
@@ -591,19 +606,27 @@ function createTransport(options) {
     if (perCall !== void 0) return perCall;
     return options.maxResponseBytes ?? 0;
   }
-  async function exchange(spec) {
+  async function exchange(spec, keepsStream = false) {
     const url = `${base}${withQuery(spec.path, spec.query)}`;
     const headers = { ...baseHeaders, ...spec.options?.headers };
     if (spec.contentType !== void 0) headers["content-type"] = spec.contentType;
     const timeoutMs = resolveTimeout(spec);
     const deadline = startDeadline(timeoutMs, spec.options?.signal);
+    let handedOver = false;
     try {
       const init = { method: spec.method, headers, signal: deadline.signal };
       if (spec.body !== void 0) init.body = spec.body;
+      if (spec.body instanceof ReadableStream) init.duplex = "half";
       const response = await send(url, init);
-      const wantsBytes = spec.binaryAnswer === true && response.ok;
-      const answer = await readAnswer(response, resolveResponseCeiling(spec), wantsBytes);
-      return { status: response.status, url, ...answer };
+      if (keepsStream && response.ok && response.body !== null) {
+        handedOver = true;
+        const stream = response.body.pipeThrough(
+          new TransformStream({ flush: () => deadline.release() })
+        );
+        return { status: response.status, url, text: "", stream };
+      }
+      const text = await readAnswer(response, resolveResponseCeiling(spec));
+      return { status: response.status, url, stream: null, text };
     } catch (err) {
       if (err instanceof ResponseTooLargeError) {
         throw invalidResponse(`The server at ${url} answered more than this client reads: ${err.message}`, {
@@ -629,7 +652,7 @@ function createTransport(options) {
         { url }
       );
     } finally {
-      deadline.release();
+      if (!handedOver) deadline.release();
     }
   }
   function parse(status, text, path) {
@@ -656,9 +679,9 @@ function createTransport(options) {
         throw err;
       }
     },
-    async binary(spec) {
-      const { status, text, bytes, url } = await exchange(spec);
-      if (bytes !== null) return bytes;
+    async stream(spec) {
+      const { status, text, stream, url } = await exchange(spec, true);
+      if (stream !== null) return stream;
       throw errorFromBody(status, parse(status, text, url), url);
     },
     async probe(spec) {
@@ -873,4 +896,4 @@ function createNarsilClient(options) {
   };
 }
 
-export { ASYNC_IMPORT_CAPABILITY, ClientErrorCodes, ErrorCodes, INDEX_LIFECYCLE_CAPABILITY, NarsilError, REBUILD_ANALYSIS_CAPABILITY, SERVER_CAPABILITIES, ServerErrorCodes, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, createNarsilClient, isNarsilError };
+export { ASYNC_IMPORT_CAPABILITY, ClientErrorCodes, DOCUMENT_EXPORT_CAPABILITY, ErrorCodes, INDEX_LIFECYCLE_CAPABILITY, NarsilError, REBUILD_ANALYSIS_CAPABILITY, SERVER_CAPABILITIES, ServerErrorCodes, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, createNarsilClient, isNarsilError };

package/dist/{config-rBpbgTw8.d.ts → config-Bv8etwUZ.d.ts}

@@ -1,6 +1,6 @@
-import { N as NarsilConfig } from './config-Dfanyqqt.js';
-import { A as AllocationTable, N as NodeRole, a as NodeRegistration, C as ClusterCoordinator, b as NodeCapacity } from './types-gOUqhs2F.js';
-import { N as NodeTransport } from './types-D5OwhtsQ.js';
+import { N as NarsilConfig } from './config-QXU3HMpq.js';
+import { A as AllocationTable, N as NodeRole, a as NodeRegistration, C as ClusterCoordinator, b as NodeCapacity } from './types-BiUmaiWT.js';
+import { N as NodeTransport } from './types-Cb9kiY5P.js';
 
 /**
  * How much replication history a primary keeps, and how many replicas have to
@@ -41,7 +41,14 @@ interface ClusterNodeConfig {
     nodeId?: string;
     /** This node offers this much capacity, which the allocator weighs. It offers {@link DEFAULT_CAPACITY} by default. */
     capacity?: NodeCapacity;
-    /** These settings configure the engine this node runs locally, such as its persistence and durability. */
+    /**
+     * These settings configure the engine this node runs locally, such as its persistence and durability.
+     *
+     * When the node sends or receives a copy of an index, it writes that copy to disk so that the copy never has to fit
+     * in memory. The copy goes into a `.snapshot-transfer` directory inside the durability directory, or into the
+     * system's temporary directory when the engine has no durability directory, and the node deletes it once the
+     * transfer ends.
+     */
     engine?: NarsilConfig;
     /** These replication settings override the engine's own, and anything you leave out keeps its value. */
     replication?: Partial<ReplicationConfig>;

package/dist/{config-Dfanyqqt.d.ts → config-QXU3HMpq.d.ts}

@@ -1,6 +1,6 @@
 import { P as PersistenceAdapter, I as InvalidationAdapter, E as EmbeddingAdapter } from './adapters-79OIa4xm.js';
-import { Q as QueryParams, e as QueryResult } from './memory-C7UMCMH3.js';
-import { I as IndexConfig, A as AnyDocument } from './schema-Bgzr4g7b.js';
+import { Q as QueryParams, e as QueryResult, f as NarsilEventHandlers } from './memory-B4jMmygw.js';
+import { I as IndexConfig, A as AnyDocument } from './schema-BBOCdhND.js';
 
 /**
  * Hooks that the engine calls alongside its own work, so that an application
@@ -197,6 +197,30 @@ interface NarsilConfig {
     analysis?: AnalysisConfig;
     /** These limits close indexes while keeping their durable files ready to reopen. */
     lifecycle?: IndexLifecycleConfig;
+    /**
+     * These listeners receive events from the moment that the engine starts.
+     * The engine registers each one before it recovers any index, so a listener
+     * here receives the `layoutUpgrade` events of that recovery, which come
+     * before {@link createNarsil} returns the engine. For a name outside
+     * {@link NarsilEventMap}, or an entry that is not a function,
+     * {@link createNarsil} throws `CONFIG_INVALID`.
+     */
+    events?: NarsilEventHandlers;
+    /**
+     * This is the most work that the engine may do on the pattern tests of one
+     * search, counted over every partition that it searches. The engine adds one
+     * unit for each run of three code points that it looks up in a pattern
+     * index, one for each entry that it reads from a pattern index, and one for
+     * each step of its matcher. For a text whose case fold is shorter than three
+     * code points, it counts each document that it checks as an entry that it
+     * reads. It counts an `in` or `nin` test as one `eq` test for each distinct
+     * value in its list. Once the count passes the cap, the engine throws
+     * `SEARCH_WORK_CAP_EXCEEDED`. The cap
+     * defaults to 25,000,000 units. For any value other than a whole number from
+     * 1 to `Number.MAX_SAFE_INTEGER`, {@link createNarsil} throws
+     * `CONFIG_INVALID`.
+     */
+    patternWorkCap?: number;
 }
 /**
  * Limits on the indexes one engine keeps open in memory.

package/dist/direct-executor-5SRDFZAS.mjs

@@ -0,0 +1,13 @@
+export { createDirectExecutor } from './chunk-THMSFOJO.mjs';
+import './chunk-4MQ5F4IL.mjs';
+import './chunk-3YKWSO54.mjs';
+import './chunk-AK3BLGCI.mjs';
+import './chunk-TGP5M5R7.mjs';
+import './chunk-WVDFG45M.mjs';
+import './chunk-ZJ4CSAB2.mjs';
+import './chunk-PU43WDY4.mjs';
+import './chunk-XW25X6AU.mjs';
+import './chunk-ZKRV5M2P.mjs';
+import './chunk-U2BKYEC7.mjs';
+import './chunk-LJYTW7GT.mjs';
+import './chunk-I64LXKO3.mjs';