@delali/narsil 0.2.4-next.51 → 0.2.4-next.54

package/dist/index.d.ts

@@ -1,13 +1,14 @@
-import { c as StopWordOverride, C as CustomTokenizer } from './schema-BqRx9t4E.js';
-export { A as AnyDocument, B as BM25Params, E as EmbeddingFieldConfig, F as FieldType, I as IndexConfig, b as InsertOptions, P as PartitionConfig, S as SchemaDefinition, a as ScoringMode, V as VectorIndexConfig, d as VectorQuantizationMode, W as WriteOptions } from './schema-BqRx9t4E.js';
+import { b as StopWordOverride, C as CustomTokenizer } from './schema-mLpXZBEh.js';
+export { A as AnyDocument, B as BM25Params, E as EmbeddingFieldConfig, F as FieldType, I as IndexConfig, a as InsertOptions, P as PartitionConfig, S as SchemaDefinition, c as ScoringMode, V as VectorIndexConfig, d as VectorQuantizationMode, e as VectorStorageMode, W as WriteOptions } from './schema-mLpXZBEh.js';
 import { L as LanguageModule } from './language-DB8KG1z5.js';
 export { T as TokenizerConfig } from './language-DB8KG1z5.js';
-export { A as ArrayFilter, B as BatchResult, C as ClientErrorCode, a as ClientErrorCodes, k as ComparisonFilter, D as DocumentProjection, E as ErrorCode, b as ErrorCodes, F as FacetConfig, l as FacetResult, m as FieldFilter, n as FilterExpression, G as GeoFilter, o as GeoPolygonFilter, p as GeoRadiusFilter, q as GroupConfig, r as GroupReducer, s as GroupResult, H as HighlightConfig, t as HighlightMatch, u as Hit, v as HybridConfig, I as IndexInfo, f as IndexStats, L as ListParams, g as ListResult, w as ListedDocument, M as MemoryStats, N as NarsilError, c as NarsilErrorCode, P as PartitionStatsResult, h as PreflightResult, x as PresenceFilter, y as ProcessMemoryReport, z as QueryCoverage, Q as QueryParams, e as QueryResult, J as ScoreComponents, K as SearchMode, S as ServerErrorCode, d as ServerErrorCodes, O as SortField, R as SortSpec, T as StringFilter, i as SuggestParams, j as SuggestResult, U as TermMatchPolicy, V as VectorMaintenanceResult, W as VectorQueryConfig, X as WorkerCopyReport } from './memory-Bzd5xcEW.js';
-import { N as NarsilConfig } from './config-OON7IJ_B.js';
-export { A as AnalysisConfig, D as DurabilityConfig, I as IndexContext, a as IndexLifecycleConfig, b as InsertContext, M as MainCopyQueries, c as NarsilPlugin, P as PartitionContext, R as RemoveContext, S as SearchContext, d as StaleAnalysis, U as UpdateContext, W as WorkerConfig, e as WorkerContext } from './config-OON7IJ_B.js';
-import { a as Narsil } from './engine-9PtFY50q.js';
-export { D as DocumentWriteOperations, I as IndexLifecycleOperations, N as NarsilEventMap } from './engine-9PtFY50q.js';
+export { A as ArrayFilter, B as BatchResult, C as ClientErrorCode, a as ClientErrorCodes, l as ComparisonFilter, D as DocumentProjection, E as ErrorCode, b as ErrorCodes, F as FacetConfig, m as FacetResult, n as FieldFilter, o as FilterExpression, G as GeoFilter, p as GeoPolygonFilter, q as GeoRadiusFilter, r as GroupConfig, s as GroupReducer, t as GroupResult, H as HighlightConfig, u as HighlightMatch, v as Hit, w as HybridConfig, I as IndexInfo, f as IndexStats, L as ListParams, g as ListResult, x as ListedDocument, M as MemoryStats, N as NarsilError, c as NarsilErrorCode, P as PartitionStatsResult, h as PreflightResult, y as PresenceFilter, z as ProcessMemoryReport, J as QueryCoverage, Q as QueryParams, e as QueryResult, K as ScoreComponents, O as SearchMode, S as ServerErrorCode, d as ServerErrorCodes, R as SortField, T as SortSpec, U as StringFilter, j as SuggestParams, k as SuggestResult, W as TermMatchPolicy, V as VectorMaintenanceResult, X as VectorQueryConfig, Y as WorkerCopyReport, i as isNarsilError } from './memory-xrXOZMbw.js';
+import { N as NarsilConfig } from './config-bXxnJrQc.js';
+export { A as AnalysisConfig, D as DurabilityConfig, I as IndexContext, a as IndexLifecycleConfig, b as InsertContext, M as MainCopyQueries, c as NarsilPlugin, P as PartitionContext, R as RemoveContext, S as SearchContext, d as StaleAnalysis, U as UpdateContext, W as WorkerConfig, e as WorkerContext } from './config-bXxnJrQc.js';
+import { a as Narsil } from './engine-Dj4I91Jv.js';
+export { D as DocumentWriteOperations, I as IndexLifecycleOperations, N as NarsilEventMap } from './engine-Dj4I91Jv.js';
 export { E as EmbeddingAdapter, I as InvalidationAdapter, a as InvalidationEvent, b as PartitionStatistics, P as PersistenceAdapter } from './adapters-79OIa4xm.js';
+export { i as isSimdAvailable } from './simd-DW5AtJ6B.js';
 
 /**
  * Registers a tokeniser under a name that an index config can then reference.
@@ -165,19 +166,6 @@ declare function getLanguage(name: string): LanguageModule;
  */
 declare function createNarsil(config?: NarsilConfig): Promise<Narsil>;
 
-/**
- * Reports whether the runtime loaded the SIMD module that speeds up vector
- * distance work.
- *
- * Vector search works either way, so read this to explain a difference in
- * search latency between two hosts rather than to decide whether to search.
- *
- * @returns True once the SIMD module has loaded.
- *
- * @public
- */
-declare function isSimdAvailable(): boolean;
-
 /**
  * Engine version written into the engine-version bytes of every `.nrsl` file,
  * for diagnostics.
@@ -190,4 +178,4 @@ declare function isSimdAvailable(): boolean;
  */
 declare const VERSION = "0.1.0";
 
-export { CustomTokenizer, LanguageModule, Narsil, NarsilConfig, StopWordOverride, VERSION, clearNormalizationCache, configureNormalizationCache, createNarsil, getLanguage, getNormalizationCacheSize, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isSimdAvailable, registerLanguage, registerStopWords, registerTokenizer, resetNormalizationCache };
+export { CustomTokenizer, LanguageModule, Narsil, NarsilConfig, StopWordOverride, VERSION, clearNormalizationCache, configureNormalizationCache, createNarsil, getLanguage, getNormalizationCacheSize, getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerLanguage, registerStopWords, registerTokenizer, resetNormalizationCache };

package/dist/index.mjs

@@ -1,18 +1,19 @@
-export { VERSION, createNarsil } from './chunk-ND34I3SV.mjs';
-import './chunk-ZHUQKZBE.mjs';
+export { VERSION, createNarsil } from './chunk-BH5SYB5W.mjs';
 import './chunk-GCM3JFVA.mjs';
-import './chunk-PIWKZPP7.mjs';
-import './chunk-XE6XR2OE.mjs';
-export { getLanguage, getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerLanguage, registerStopWords, registerTokenizer } from './chunk-BEIK3EOZ.mjs';
-export { clearNormalizationCache, configureNormalizationCache, getNormalizationCacheSize, resetNormalizationCache } from './chunk-CMVG2UEF.mjs';
+import './chunk-4NVPQ6S5.mjs';
+export { getLanguage, getStopWords, getTokenizer, hasStopWords, hasTokenizer, registerLanguage, registerStopWords, registerTokenizer } from './chunk-XNQAIO74.mjs';
 import './chunk-AV4IJKD2.mjs';
-import './chunk-CBLS46IE.mjs';
+import './chunk-TVT5V4E7.mjs';
+import './chunk-D2S642IV.mjs';
+export { clearNormalizationCache, configureNormalizationCache, getNormalizationCacheSize, resetNormalizationCache } from './chunk-5T6AOR37.mjs';
+import './chunk-L225SHNB.mjs';
 import './chunk-TGP5M5R7.mjs';
-import './chunk-PMBHH44R.mjs';
-export { isSimdAvailable } from './chunk-X6YZO4MQ.mjs';
-import './chunk-RP23PWMV.mjs';
-import './chunk-KMMJMDUA.mjs';
+export { isSimdAvailable } from './chunk-U2AL3SON.mjs';
+import './chunk-ZJ4CSAB2.mjs';
+import './chunk-UTOFOJOR.mjs';
+import './chunk-3L4U6EJQ.mjs';
+import './chunk-IFBKLBGB.mjs';
 import './chunk-U2BKYEC7.mjs';
 import './chunk-2GWVQWGA.mjs';
-import './chunk-WYJXSLER.mjs';
-export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes } from './chunk-P4ELXVJQ.mjs';
+import './chunk-POWOTUKJ.mjs';
+export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, isNarsilError } from './chunk-FRQVMFY7.mjs';

package/dist/{memory-Bzd5xcEW.d.ts → memory-xrXOZMbw.d.ts}

@@ -1,4 +1,4 @@
-import { A as AnyDocument, S as SchemaDefinition, a as ScoringMode } from './schema-BqRx9t4E.js';
+import { A as AnyDocument, S as SchemaDefinition, c as ScoringMode } from './schema-mLpXZBEh.js';
 
 /**
  * Every code a {@link NarsilError} carries, grouped by the part of the engine
@@ -27,6 +27,7 @@ declare const ErrorCodes: {
     readonly WORKER_CRASHED: "WORKER_CRASHED";
     readonly WORKER_BUSY: "WORKER_BUSY";
     readonly WORKER_TIMEOUT: "WORKER_TIMEOUT";
+    readonly WORKER_ACTION_FAILED: "WORKER_ACTION_FAILED";
     readonly PERSISTENCE_SAVE_FAILED: "PERSISTENCE_SAVE_FAILED";
     readonly PERSISTENCE_LOAD_FAILED: "PERSISTENCE_LOAD_FAILED";
     readonly PERSISTENCE_DELETE_FAILED: "PERSISTENCE_DELETE_FAILED";
@@ -140,13 +141,15 @@ declare const ServerErrorCodes: {
  */
 type ServerErrorCode = (typeof ServerErrorCodes)[keyof typeof ServerErrorCodes];
 /**
- * Every code the HTTP client raises when a request never reaches a server, or
- * when the client cannot read the answer.
+ * Every code that the caller's own side raises, where a request never reaches
+ * a server, or where the caller cannot read the answer.
  *
- * No server sends one of these, so a failure under one of them means the
- * exchange broke before the operation ran. `STATUS_BY_CODE` in
- * `src/server/errors.ts` therefore maps none of them, because no request can
- * arrive under one and no HTTP status belongs to one.
+ * The HTTP client raises the first five. The React bindings raise
+ * `CLIENT_UNEXPECTED_ERROR` alone, which reports a fault inside a hook. No
+ * server sends any of them, so a failure under one means the exchange broke
+ * before the operation ran. `STATUS_BY_CODE` in `src/server/errors.ts`
+ * therefore maps none of them, because no request can arrive under one and no
+ * HTTP status belongs to one.
  *
  * @public
  */
@@ -204,6 +207,22 @@ declare class NarsilError extends Error {
      */
     constructor(code: NarsilErrorCode, message: string, details?: Record<string, unknown>);
 }
+/**
+ * Reports whether a caught value is a {@link NarsilError}, including one that
+ * another entry point of this package raises.
+ *
+ * Each browser bundle holds its own copy of the class, so an `instanceof` test
+ * inside the React bindings returns false for an error that the client raises,
+ * although that error still holds its code. This function tests for the marker
+ * that the constructor writes, so it returns true for an error from any entry
+ * point.
+ *
+ * @param value - The value that a `catch` block receives.
+ * @returns True where the value holds a code in {@link NarsilError.code}.
+ *
+ * @public
+ */
+declare function isNarsilError(value: unknown): value is NarsilError;
 
 /**
  * What {@link Narsil.query} returns: the ranked hits and everything the query
@@ -283,7 +302,12 @@ interface Hit<T = AnyDocument> {
  * @public
  */
 interface ScoreComponents {
-    /** Each query term appears in this document this often, keyed by term. */
+    /**
+     * Each query term appears in one field of this document this many times,
+     * under a key of `field:term`. A term that appears in two fields therefore
+     * has two entries here, while the keys of {@link ScoreComponents.idf} hold
+     * the bare term.
+     */
     termFrequencies: Record<string, number>;
     /** Each field the query searched holds this many tokens, keyed by field. */
     fieldLengths: Record<string, number>;
@@ -298,7 +322,13 @@ interface ScoreComponents {
 interface HighlightMatch {
     /** This is the field's text around the match, wrapped in the query's tags. */
     snippet: string;
-    /** The match covers these character ranges in the original field, for rendering the highlight yourself. */
+    /**
+     * Each range gives the start and the end of one match in the original field,
+     * so you can render the highlight yourself. Where the snippet covers part of
+     * the field alone, the engine lists only the matches that the snippet
+     * displays. Every offset is a character count from the start of the original
+     * field, whatever the snippet contains.
+     */
     positions: Array<{
         start: number;
         end: number;
@@ -462,7 +492,12 @@ interface SuggestResult {
 interface VectorMaintenanceResult {
     /** This describes the named vector field. */
     fieldName: string;
-    /** Tombstones make up this share of the graph's nodes, from 0 to 1. */
+    /**
+     * Tombstones make up this share of the graph's nodes, from 0 to 1. Before
+     * the first build, where {@link VectorMaintenanceResult.graphCount} reads 0,
+     * the engine divides by the number of stored vectors, because no graph
+     * exists yet.
+     */
     tombstoneRatio: number;
     /** The field holds this many HNSW graphs: 0 before the first build and 1 once a graph exists. */
     graphCount: number;
@@ -744,7 +779,12 @@ interface QueryParams {
     sort?: SortSpec;
     /** These settings collapse the hits into groups by field value. */
     group?: GroupConfig;
-    /** The query returns this many hits, and 10 by default. */
+    /**
+     * The query returns this many hits, and 10 by default. Pass 0 to read the
+     * match count with no hits. The engine reads a value below 0 as 0. It falls
+     * back to the default for `NaN` and for an infinite value, so a page size
+     * that you compute from user input never fails the query.
+     */
     limit?: number;
     /** The query skips this many hits before returning. A deep offset costs more than a cursor. */
     offset?: number;
@@ -845,6 +885,16 @@ interface VectorQueryConfig {
      * value when omitted.
      */
     efSearch?: number;
+    /**
+     * How many times `limit` a quantized field re-scores against its
+     * full-precision vectors before it returns the best `limit`. A value below
+     * 1 or one that is not a finite number fails with `CONFIG_INVALID`. The
+     * engine ignores this on a field whose quantization is `none`. When a query
+     * omits it, the engine takes 3 for `osq1` and `osq2`, 2 for `osq8`, and 2
+     * for `osq4` at 1,024 dimensions and above, but 5 for `osq4` below 1,024,
+     * where a four-bit code ranks the true neighbours less reliably.
+     */
+    oversample?: number;
 }
 /**
  * How a hybrid query merges its keyword ranking with its vector ranking.
@@ -933,7 +983,12 @@ interface HighlightConfig {
     preTag?: string;
     /** This closes each match, and is `</mark>` by default. */
     postTag?: string;
-    /** A snippet runs to this many characters before the engine trims it. */
+    /**
+     * The engine takes this many characters of the field around the densest run
+     * of matches, 200 by default. The snippet that comes back is longer than
+     * that number, because the engine then adds the opening and closing tags,
+     * and an ellipsis at each end where it cut the field.
+     */
     maxSnippetLength?: number;
 }
 /**
@@ -1073,4 +1128,4 @@ interface MemoryStats {
     }>;
 }
 
-export { type ArrayFilter as A, type BatchResult as B, type ClientErrorCode as C, type DocumentProjection as D, type ErrorCode as E, type FacetConfig as F, type GeoFilter as G, type HighlightConfig as H, type IndexInfo as I, type ScoreComponents as J, type SearchMode as K, type ListParams as L, type MemoryStats as M, NarsilError as N, type SortField as O, type PartitionStatsResult as P, type QueryParams as Q, type SortSpec as R, type ServerErrorCode as S, type StringFilter as T, type TermMatchPolicy as U, type VectorMaintenanceResult as V, type VectorQueryConfig as W, type WorkerCopyReport as X, ClientErrorCodes as a, ErrorCodes as b, type NarsilErrorCode as c, ServerErrorCodes as d, type QueryResult as e, type IndexStats as f, type ListResult as g, type PreflightResult as h, type SuggestParams as i, type SuggestResult as j, type ComparisonFilter as k, type FacetResult as l, type FieldFilter as m, type FilterExpression as n, type GeoPolygonFilter as o, type GeoRadiusFilter as p, type GroupConfig as q, type GroupReducer as r, type GroupResult as s, type HighlightMatch as t, type Hit as u, type HybridConfig as v, type ListedDocument as w, type PresenceFilter as x, type ProcessMemoryReport as y, type QueryCoverage as z };
+export { type ArrayFilter as A, type BatchResult as B, type ClientErrorCode as C, type DocumentProjection as D, type ErrorCode as E, type FacetConfig as F, type GeoFilter as G, type HighlightConfig as H, type IndexInfo as I, type QueryCoverage as J, type ScoreComponents as K, type ListParams as L, type MemoryStats as M, NarsilError as N, type SearchMode as O, type PartitionStatsResult as P, type QueryParams as Q, type SortField as R, type ServerErrorCode as S, type SortSpec as T, type StringFilter as U, type VectorMaintenanceResult as V, type TermMatchPolicy as W, type VectorQueryConfig as X, type WorkerCopyReport as Y, ClientErrorCodes as a, ErrorCodes as b, type NarsilErrorCode as c, ServerErrorCodes as d, type QueryResult as e, type IndexStats as f, type ListResult as g, type PreflightResult as h, isNarsilError as i, type SuggestParams as j, type SuggestResult as k, type ComparisonFilter as l, type FacetResult as m, type FieldFilter as n, type FilterExpression as o, type GeoPolygonFilter as p, type GeoRadiusFilter as q, type GroupConfig as r, type GroupReducer as s, type GroupResult as t, type HighlightMatch as u, type Hit as v, type HybridConfig as w, type ListedDocument as x, type PresenceFilter as y, type ProcessMemoryReport as z };

package/dist/persistence/durability/checkpoint-worker.d.ts

@@ -1,4 +1,4 @@
-import { P as PartitionConfig, a as ScoringMode, V as VectorIndexConfig } from '../../schema-BqRx9t4E.js';
+import { P as PartitionConfig, c as ScoringMode, V as VectorIndexConfig } from '../../schema-mLpXZBEh.js';
 import '../../adapters-79OIa4xm.js';
 
 interface IndexMetadata {
@@ -43,6 +43,119 @@ interface IndexEmbeddingMetadata {
     adapter?: string;
     fields: Record<string, string | string[]>;
 }
+/**
+ * Persisted surface-form dictionary of one partition. Keys are the
+ * unstemmed display tokens; the value is the occurrence count when the
+ * surface equals its index token, or `[count, indexToken]` when stemming
+ * changed it.
+ */
+type SerializedSurfaceForms = Record<string, number | [number, string]>;
+
+interface SegmentPayload {
+    documentCount: number;
+    docIds: string[];
+    fieldNames: string[];
+    tokens: string[];
+    postingOffsets: Uint32Array;
+    postingDocIds: Uint32Array;
+    postingFrequencies: Uint16Array;
+    postingFieldIndices: Uint8Array;
+    positionOffsets: Uint32Array | null;
+    positionValues: Uint32Array | null;
+    fieldLengthNames: string[];
+    fieldLengthColumns: Uint32Array[];
+    totalFieldLengths: Record<string, number>;
+    docFrequencies: Record<string, number>;
+    surfaceForms: SerializedSurfaceForms | null;
+    numeric: Array<{
+        fieldPath: string;
+        docIds: Uint32Array;
+        values: Float64Array;
+    }>;
+    boolean: Array<{
+        fieldPath: string;
+        trueDocs: Uint32Array;
+        falseDocs: Uint32Array;
+    }>;
+    enums: Array<{
+        fieldPath: string;
+        values: string[];
+        offsets: Uint32Array;
+        docIds: Uint32Array;
+    }>;
+    geo: Array<{
+        fieldPath: string;
+        docIds: Uint32Array;
+        latitudes: Float64Array;
+        longitudes: Float64Array;
+    }>;
+}
+
+interface SegmentPostingColumns {
+    postingOffsets: Uint32Array;
+    postingDocIds: Uint32Array;
+    postingFrequencies: Uint16Array;
+    postingFieldIndices: Uint8Array;
+    positionOffsets: Uint32Array | null;
+    positionValues: Uint32Array | null;
+}
+interface SegmentColumns extends SegmentPostingColumns {
+    documentCount: number;
+    fieldNames: readonly string[];
+    fieldLengthNames: readonly string[];
+    fieldLengthColumns: readonly Uint32Array[];
+    totalFieldLengths: Readonly<Record<string, number>>;
+    numeric: SegmentPayload['numeric'];
+    boolean: SegmentPayload['boolean'];
+    enums: SegmentPayload['enums'];
+    geo: SegmentPayload['geo'];
+    surfaceForms: SerializedSurfaceForms | null;
+}
+
+interface EncodedDocumentTableData {
+    blob: Uint8Array;
+    offsets: Uint32Array;
+}
+
+interface ExternalIdTableData {
+    blob: Uint8Array;
+    offsets: Uint32Array;
+    sortedOrdinals: Uint32Array;
+}
+
+interface SurfaceTableData {
+    blob: Uint8Array;
+    offsets: Uint32Array;
+    counts: Uint32Array;
+}
+
+interface FrozenTokenTableData {
+    blob: Uint8Array;
+    offsets: Uint32Array;
+    payloadSlots: Uint32Array;
+    documentFrequencies: Uint32Array;
+}
+
+interface SharedSegmentSnapshot extends Omit<SegmentColumns, 'surfaceForms'> {
+    segmentId: string;
+    tokenTable: FrozenTokenTableData;
+    idTable: ExternalIdTableData;
+    documentTable: EncodedDocumentTableData;
+    /** The surface forms packed flat, or null where the segment holds none. */
+    surfaceTable: SurfaceTableData | null;
+}
+
+interface CapturedFrozenSegment {
+    snapshot: SharedSegmentSnapshot;
+    tombstonedDocIds: string[];
+}
+interface CapturedWholePartition {
+    partitionId: number;
+    totalPartitions: number;
+    docCount: number;
+    liveTail: Uint8Array | null;
+    frozen: CapturedFrozenSegment[];
+}
 
 interface PartitionCheckpoint {
     partitionId: number;
@@ -50,20 +163,42 @@ interface PartitionCheckpoint {
     primaryTerm: number;
 }
 
+interface SegmentRef {
+    id: number;
+    key: string;
+    docCount: number;
+    tombstoneCount: number;
+}
+interface PartitionManifestEntry {
+    partitionId: number;
+    nextSegmentId: number;
+    segments: SegmentRef[];
+}
+
+interface CheckpointSegmentsWritten {
+    checkpoint: PartitionCheckpoint[];
+    partitions: PartitionManifestEntry[];
+}
+
 interface CheckpointWorkerRequest {
     root: string;
     metadata: IndexMetadata;
     targets: PartitionCheckpoint[];
     compactionThreshold: number;
+    capturedPartitions?: CapturedWholePartition[];
 }
 interface CheckpointWorkerSuccess {
     type: 'success';
+    segments: CheckpointSegmentsWritten;
 }
 interface CheckpointWorkerError {
     type: 'error';
     message: string;
 }
-type CheckpointWorkerMessage = CheckpointWorkerSuccess | CheckpointWorkerError;
+interface CheckpointWorkerHeartbeat {
+    type: 'heartbeat';
+}
+type CheckpointWorkerMessage = CheckpointWorkerSuccess | CheckpointWorkerError | CheckpointWorkerHeartbeat;
 declare function handleRequest(raw: unknown): Promise<CheckpointWorkerSuccess>;
 
-export { type CheckpointWorkerError, type CheckpointWorkerMessage, type CheckpointWorkerRequest, type CheckpointWorkerSuccess, handleRequest };
+export { type CheckpointWorkerError, type CheckpointWorkerHeartbeat, type CheckpointWorkerMessage, type CheckpointWorkerRequest, type CheckpointWorkerSuccess, handleRequest };

package/dist/persistence/durability/checkpoint-worker.mjs

@@ -1,26 +1,27 @@
-import { createDurableDirectory, writeSegmentedCheckpoint } from '../../chunk-ND34I3SV.mjs';
-import '../../chunk-ZHUQKZBE.mjs';
+import { CHECKPOINT_WORKER_HEARTBEAT_MS, createDurableDirectory, writeCheckpointSegments } from '../../chunk-BH5SYB5W.mjs';
 import '../../chunk-GCM3JFVA.mjs';
-import '../../chunk-PIWKZPP7.mjs';
-import '../../chunk-XE6XR2OE.mjs';
-import '../../chunk-BEIK3EOZ.mjs';
-import '../../chunk-CMVG2UEF.mjs';
+import '../../chunk-4NVPQ6S5.mjs';
+import '../../chunk-XNQAIO74.mjs';
 import '../../chunk-AV4IJKD2.mjs';
-import '../../chunk-CBLS46IE.mjs';
+import '../../chunk-TVT5V4E7.mjs';
+import '../../chunk-D2S642IV.mjs';
+import '../../chunk-5T6AOR37.mjs';
+import '../../chunk-L225SHNB.mjs';
 import '../../chunk-TGP5M5R7.mjs';
-import '../../chunk-PMBHH44R.mjs';
-import '../../chunk-X6YZO4MQ.mjs';
-import '../../chunk-RP23PWMV.mjs';
-import '../../chunk-KMMJMDUA.mjs';
+import '../../chunk-U2AL3SON.mjs';
+import '../../chunk-ZJ4CSAB2.mjs';
+import '../../chunk-UTOFOJOR.mjs';
+import '../../chunk-3L4U6EJQ.mjs';
+import '../../chunk-IFBKLBGB.mjs';
 import '../../chunk-U2BKYEC7.mjs';
 import '../../chunk-2GWVQWGA.mjs';
-import '../../chunk-WYJXSLER.mjs';
-import '../../chunk-P4ELXVJQ.mjs';
+import '../../chunk-POWOTUKJ.mjs';
+import '../../chunk-FRQVMFY7.mjs';
 
 // src/persistence/durability/rebuild.ts
-async function rebuildSnapshotFromDurable(root, metadata, targets, compactionThreshold) {
+async function rebuildSegmentsFromDurable(root, metadata, targets, compactionThreshold, capturedPartitions = []) {
   const directory = createDurableDirectory(root);
-  await writeSegmentedCheckpoint({ directory, metadata, targets, compactionThreshold });
+  return writeCheckpointSegments({ directory, metadata, targets, compactionThreshold, capturedPartitions });
 }
 
 // src/persistence/durability/checkpoint-worker.ts
@@ -38,8 +39,17 @@ async function handleRequest(raw) {
   if (!Number.isInteger(request.compactionThreshold) || request.compactionThreshold <= 0) {
     throw new Error("Checkpoint request has an invalid compaction threshold");
   }
-  await rebuildSnapshotFromDurable(request.root, request.metadata, request.targets, request.compactionThreshold);
-  return { type: "success" };
+  if (request.capturedPartitions !== void 0 && !Array.isArray(request.capturedPartitions)) {
+    throw new Error("Checkpoint request names captured partitions in a shape the worker cannot read");
+  }
+  const segments = await rebuildSegmentsFromDurable(
+    request.root,
+    request.metadata,
+    request.targets,
+    request.compactionThreshold,
+    request.capturedPartitions
+  );
+  return { type: "success", segments };
 }
 async function setupAsync() {
   let parentPort = null;
@@ -54,10 +64,14 @@ async function setupAsync() {
   }
   const port = parentPort;
   port.on("message", (raw) => {
+    const heartbeat = setInterval(
+      () => port.postMessage({ type: "heartbeat" }),
+      CHECKPOINT_WORKER_HEARTBEAT_MS
+    );
     handleRequest(raw).then((result) => port.postMessage(result)).catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
       port.postMessage({ type: "error", message });
-    });
+    }).finally(() => clearInterval(heartbeat));
   });
 }
 function setupWorker() {

package/dist/react.d.ts

@@ -1,10 +1,10 @@
-import { N as NarsilError, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, Q as QueryParams, h as PreflightResult, e as QueryResult, i as SuggestParams, j as SuggestResult } from './memory-Bzd5xcEW.js';
-export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes } from './memory-Bzd5xcEW.js';
-import { e as TaskRecord, d as TaskProgress, b as ImportResult, c as TaskListQuery, T as TaskListPage } from './tasks-DT7L1p6w.js';
-export { I as ImportError, f as TaskStatus, g as TaskType } from './tasks-DT7L1p6w.js';
+import { N as NarsilError, L as ListParams, g as ListResult, I as IndexInfo, f as IndexStats, Q as QueryParams, h as PreflightResult, e as QueryResult, j as SuggestParams, k as SuggestResult } from './memory-xrXOZMbw.js';
+export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-xrXOZMbw.js';
+import { e as TaskRecord, d as TaskProgress, b as ImportResult, c as TaskListQuery, T as TaskListPage } from './tasks-Df73Tjgq.js';
+export { I as ImportError, f as TaskStatus, g as TaskType } from './tasks-Df73Tjgq.js';
 import { ReactNode, ReactElement } from 'react';
-import { N as NarsilClient, I as ImportSource } from './client-B_X6_AbT.js';
-import { A as AnyDocument } from './schema-BqRx9t4E.js';
+import { N as NarsilClient, I as ImportSource } from './client-CQUqt9Ir.js';
+import { A as AnyDocument } from './schema-mLpXZBEh.js';
 import './adapters-79OIa4xm.js';
 
 /**
@@ -297,7 +297,7 @@ declare function useSuggest(indexName: string, params: SuggestParams, options?:
  *
  * @public
  */
-interface NarsilTaskOptions extends NarsilReadOptions {
+interface NarsilTaskOptions extends Omit<NarsilReadOptions, 'refreshIntervalMs'> {
     /** The hook asks again this often while the task runs, and every 250 ms
      * unless you say otherwise, which is how often a running import writes its
      * progress. It stops once the task reaches a final status. */
@@ -306,10 +306,10 @@ interface NarsilTaskOptions extends NarsilReadOptions {
 /**
  * Follows one long-running operation, and stops asking once it finishes.
  *
- * The hook polls while the task is queued or running, pauses while the page is
- * hidden, and reads the figures once more as soon as the page comes back. A
- * failed task arrives as a record carrying its `error`, because a part-finished
- * import still reports what it indexed, so read the status you get.
+ * The hook polls while the task runs, pauses while the page is hidden, and
+ * reads the figures once more as soon as the page comes back. A failed task
+ * arrives as a record carrying its `error`, because a part-finished import
+ * still reports what it indexed, so read the status you get.
  *
  * @param taskId - This names the task to follow, and a nullish or empty id
  * switches the hook off.

package/dist/react.mjs

@@ -1,6 +1,7 @@
 import { createContext, useState, useEffect, createElement, useRef, useEffectEvent, useCallback, useMemo, useContext, useSyncExternalStore } from 'react';
 
 // src/errors.ts
+var NARSIL_ERROR_MARKER = /* @__PURE__ */ Symbol.for("@delali/narsil.NarsilError");
 var ErrorCodes = {
   SCHEMA_INVALID_TYPE: "SCHEMA_INVALID_TYPE",
   SCHEMA_DEPTH_EXCEEDED: "SCHEMA_DEPTH_EXCEEDED",
@@ -18,6 +19,7 @@ var ErrorCodes = {
   WORKER_CRASHED: "WORKER_CRASHED",
   WORKER_BUSY: "WORKER_BUSY",
   WORKER_TIMEOUT: "WORKER_TIMEOUT",
+  WORKER_ACTION_FAILED: "WORKER_ACTION_FAILED",
   PERSISTENCE_SAVE_FAILED: "PERSISTENCE_SAVE_FAILED",
   PERSISTENCE_LOAD_FAILED: "PERSISTENCE_LOAD_FAILED",
   PERSISTENCE_DELETE_FAILED: "PERSISTENCE_DELETE_FAILED",
@@ -137,8 +139,12 @@ var NarsilError = class extends Error {
     this.name = "NarsilError";
     this.code = code;
     this.details = details ?? {};
+    Object.defineProperty(this, NARSIL_ERROR_MARKER, { value: true });
   }
 };
+function isNarsilError(value) {
+  return typeof value === "object" && value !== null && NARSIL_ERROR_MARKER in value;
+}
 
 // src/react/constants.ts
 var DEFAULT_KEEP_ALIVE_MS = 2e3;
@@ -148,7 +154,7 @@ var MAX_QUERY_KEY_DEPTH = 32;
 
 // src/react/failure.ts
 function asNarsilError(err, whatFailed) {
-  if (err instanceof NarsilError) return err;
+  if (isNarsilError(err)) return err;
   const message = err instanceof Error ? err.message : String(err);
   return new NarsilError(ClientErrorCodes.CLIENT_UNEXPECTED_ERROR, `${whatFailed} failed unexpectedly: ${message}`);
 }
@@ -519,13 +525,19 @@ function useDocuments(indexName, params, options) {
   );
 }
 
+// src/server/task-status.ts
+var TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled"]);
+function isTerminalTaskStatus(status) {
+  return TERMINAL_TASK_STATUSES.has(status);
+}
+
 // src/react/task-state.ts
 function pollInterval(interval, failed) {
   return failed ? Math.max(interval, ERROR_RETRY_INTERVAL_MS) : interval;
 }
 function isTerminalTask(record) {
   if (record === null || record === void 0) return false;
-  return record.status === "succeeded" || record.status === "failed" || record.status === "cancelled";
+  return isTerminalTaskStatus(record.status);
 }
 
 // src/react/import.ts
@@ -612,7 +624,7 @@ function useImport(indexName, options) {
     client.cancelTask(taskId, request.current).then((next) => {
       setProgress((prev) => prev.task?.id === taskId ? { task: next, error: void 0, starting: false } : prev);
     }).catch((err) => {
-      if (err instanceof NarsilError && err.code === ServerErrorCodes.TASK_NOT_CANCELLABLE) return;
+      if (isNarsilError(err) && err.code === ServerErrorCodes.TASK_NOT_CANCELLABLE) return;
       setProgress((prev) => prev.task?.id === taskId ? { ...prev, error: asNarsilError(err, "The import") } : prev);
     });
   }, [client, taskId, running, progress.starting]);
@@ -686,4 +698,4 @@ function useTasks(query, options) {
   return useRead(["listTasks", query], (client, request) => client.listTasks(query, request), options);
 }
 
-export { ClientErrorCodes, ErrorCodes, NarsilError, NarsilProvider, ServerErrorCodes, useDocument, useDocuments, useImport, useIndexes, useNarsilClient, usePreflight, useQuery, useStats, useSuggest, useTask, useTasks };
+export { ClientErrorCodes, ErrorCodes, NarsilError, NarsilProvider, ServerErrorCodes, isNarsilError, useDocument, useDocuments, useImport, useIndexes, useNarsilClient, usePreflight, useQuery, useStats, useSuggest, useTask, useTasks };