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

package/dist/{schema-BqRx9t4E.d.ts → schema-mLpXZBEh.d.ts}

@@ -40,14 +40,36 @@ type SchemaDefinition = {
     [field: string]: FieldType | SchemaDefinition;
 };
 /**
- * How the engine stores vectors once a field is promoted to an HNSW graph.
+ * How the engine codes vectors once a field is promoted to an HNSW graph.
  *
- * `sq8` quantises each component to a signed byte, which cuts memory to a
- * quarter and costs a small amount of recall. `none` keeps full precision.
+ * Every `osq` mode applies optimised scalar quantization, which centres each
+ * vector on the field's centroid and then fits an interval to that vector
+ * alone. The digit in the mode name gives the bits that each dimension's code
+ * holds, so `osq8` stores a byte per dimension, while `osq4`, `osq2`, and
+ * `osq1` store four, two, and one bit. A search ranks its candidates by their
+ * codes before it re-scores the nearest of them against the full-precision
+ * vectors. `none` stores no code, so the engine ranks by the vectors alone.
+ *
+ * When the configuration leaves this unset, the engine takes `osq4` at 384
+ * dimensions and above and `osq8` below 384.
+ *
+ * @public
+ */
+type VectorQuantizationMode = 'osq8' | 'osq4' | 'osq2' | 'osq1' | 'none';
+/**
+ * Where a vector field keeps its full-precision vectors.
+ *
+ * A `memory` field holds them in memory. A `disk` field keeps its codes and
+ * its graph in memory, while it reads a full-precision vector from the
+ * field's checkpoint file whenever a search re-scores that candidate or a
+ * document read returns it. A `disk` field therefore needs filesystem
+ * durability. Asking for one on an engine without it fails with
+ * `CONFIG_INVALID`. When the configuration leaves this unset, an engine with
+ * filesystem durability takes `disk` and every other engine takes `memory`.
  *
  * @public
  */
-type VectorQuantizationMode = 'sq8' | 'none';
+type VectorStorageMode = 'memory' | 'disk';
 /**
  * Controls when a vector field moves from a brute-force scan to an HNSW graph,
  * and how that graph is built.
@@ -74,8 +96,10 @@ interface VectorIndexConfig {
         efConstruction?: number;
         metric?: 'cosine' | 'dotProduct' | 'euclidean';
     };
-    /** The engine stores the promoted vectors at this precision, and it quantises to `sq8` by default. Set `none` to keep full precision. */
+    /** The engine codes the promoted vectors in this mode. When this is unset, it picks the mode by the field's dimension. Set `none` to rank by the vectors alone. */
     quantization?: VectorQuantizationMode;
+    /** The engine keeps the field's full-precision vectors here. When this is unset, it picks `disk` under filesystem durability and `memory` on every other engine. */
+    storage?: VectorStorageMode;
 }
 /**
  * Connects an index to an embedding adapter and says which fields feed it.
@@ -190,19 +214,26 @@ interface CustomTokenizer {
     }>;
 }
 /**
- * How an index splits its documents across partitions as it grows.
+ * How many partitions an index opens with, and how many documents it accepts.
  *
- * The engine adds a partition once a partition passes its watermark, and it
- * refuses a write once every partition is full and the ceiling is reached.
+ * An index opens with `maxPartitions` partitions and keeps that count until
+ * {@link Narsil.rebalance} changes it, because the engine adds no partition on
+ * its own. Set `watermark` to learn through the `partitionWatermark` event
+ * when an index fills its capacity.
  *
  * @public
  */
 interface PartitionConfig {
-    /** The engine refuses a write that would push one partition past this many documents. */
+    /**
+     * The index accepts this many documents for each of its partitions, so its
+     * capacity is this number multiplied by its partition count. A write beyond
+     * that capacity raises `PARTITION_CAPACITY_EXCEEDED`. Leave the field unset
+     * to accept any number.
+     */
     maxDocsPerPartition?: number;
-    /** The index grows to this many partitions and no further. */
+    /** The index opens with this many partitions, 1 by default, and no rebalance may take it higher. */
     maxPartitions?: number;
-    /** The engine adds a partition once one fills this fraction of `maxDocsPerPartition`, from 0 to 1. */
+    /** The engine emits `partitionWatermark` once the index fills this share of its capacity, above 0 and at most 1. */
     watermark?: number;
 }
 /**
@@ -250,4 +281,4 @@ interface InsertOptions extends WriteOptions {
     skipClone?: boolean;
 }
 
-export type { AnyDocument as A, BM25Params as B, CustomTokenizer as C, EmbeddingFieldConfig as E, FieldType as F, IndexConfig as I, PartitionConfig as P, SchemaDefinition as S, VectorIndexConfig as V, WriteOptions as W, ScoringMode as a, InsertOptions as b, StopWordOverride as c, VectorQuantizationMode as d };
+export type { AnyDocument as A, BM25Params as B, CustomTokenizer as C, EmbeddingFieldConfig as E, FieldType as F, IndexConfig as I, PartitionConfig as P, SchemaDefinition as S, VectorIndexConfig as V, WriteOptions as W, InsertOptions as a, StopWordOverride as b, ScoringMode as c, VectorQuantizationMode as d, VectorStorageMode as e };

package/dist/serialization/crc32-worker.mjs

@@ -1,4 +1,5 @@
-import { crc32 } from '../chunk-KMMJMDUA.mjs';
+import { crc32 } from '../chunk-3L4U6EJQ.mjs';
+import '../chunk-IFBKLBGB.mjs';
 
 // src/serialization/crc32-worker.ts
 function handleRequest(raw) {

package/dist/server.d.ts

@@ -1,14 +1,14 @@
-import { b as ServerOptions, N as NarsilServer } from './capabilities-BWm4IITU.js';
-export { A as ASYNC_IMPORT_CAPABILITY, C as CorsOptions, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, O as OnRequestHook, R as REBUILD_ANALYSIS_CAPABILITY, c as RequestContext, d as RequestDenial, S as SERVER_CAPABILITIES, e as ServerLimits, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-BWm4IITU.js';
-import { a as Narsil } from './engine-9PtFY50q.js';
-import { d as TaskProgress, b as ImportResult, h as TaskStore, e as TaskRecord } from './tasks-DT7L1p6w.js';
-export { C as CapabilitiesResponse, a as CreateIndexEmbedding, i as CreateIndexRequest, H as HttpIndexConfig, I as ImportError, M as MemoryStatsResponse, T as TaskListPage, c as TaskListQuery, f as TaskStatus, g as TaskType } from './tasks-DT7L1p6w.js';
-export { d as ServerErrorCodes } from './memory-Bzd5xcEW.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-xrXOZMbw.js';
+import { b as ServerOptions, N as NarsilServer } from './capabilities-DlYw0Ov0.js';
+export { A as ASYNC_IMPORT_CAPABILITY, C as CorsOptions, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, O as OnRequestHook, R as REBUILD_ANALYSIS_CAPABILITY, c as RequestContext, d as RequestDenial, S as SERVER_CAPABILITIES, e as ServerLimits, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-DlYw0Ov0.js';
+import { a as Narsil } from './engine-Dj4I91Jv.js';
+import { d as TaskProgress, b as ImportResult, h as TaskStore, e as TaskRecord } from './tasks-Df73Tjgq.js';
+export { C as CapabilitiesResponse, a as CreateIndexEmbedding, i as CreateIndexRequest, H as HttpIndexConfig, I as ImportError, M as MemoryStatsResponse, T as TaskListPage, c as TaskListQuery, f as TaskStatus, g as TaskType } from './tasks-Df73Tjgq.js';
+import './schema-mLpXZBEh.js';
 import './adapters-79OIa4xm.js';
-import './config-Czh2YNDi.js';
-import './config-OON7IJ_B.js';
-import './schema-BqRx9t4E.js';
-import './types-DXPxaXPO.js';
+import './config-CNas6wJH.js';
+import './config-bXxnJrQc.js';
+import './types-BTIVO8DI.js';
 import './types-D5OwhtsQ.js';
 
 /**
@@ -59,6 +59,9 @@ type TaskOperation = (ctx: TaskContext) => Promise<void>;
  * @param options - Address, CORS, request limits, the authentication hook, and
  * the task store. Omit it to bind to loopback with the default limits.
  * @returns The server, ready for {@link NarsilServer.listen}.
+ * @throws A `NarsilError` with `CONFIG_INVALID` where the first argument is
+ * some value other than an engine, and where a field of `options.limits` holds
+ * a value outside its range.
  *
  * @public
  */

package/dist/server.mjs

@@ -1,12 +1,14 @@
-import { DEFAULT_MAX_RETAINED_TASKS, loadUWebSockets, resolveCors, authorizerFor, createSharedGateBuffer, gateSlotOfWorker, createRouteRunner, corsWriter, createSharedRequestGate, MAIN_THREAD_GATE_SLOT, registerServerRoutes, DEFAULT_MAX_CONCURRENT_TASKS, DEFAULT_MAX_TASK_PAGE_SIZE, DEFAULT_MAX_IMPORT_ERRORS, DEFAULT_MAX_FETCH_DOCUMENTS, DEFAULT_MAX_RESULT_WINDOW, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_IMPORT_BATCH_SIZE, DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_IMPORT_BYTES, DEFAULT_MAX_BODY_BYTES, RUNNING_TASK_TTL_MS, DEFAULT_TASK_PAGE_SIZE, TERMINAL_TASK_TTL_MS, TASK_PROGRESS_WRITE_INTERVAL_MS, serializeNarsilError, acceptorOf, createDocumentReadHandlers, sendError, respondError, respondJson, MAX_INDEX_TOUCH_INTERVAL_MS, INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT, clearGateSlot, parseJson, validateCreateIndex, rejectInvalid, validateBatch, serializeBatchResult, validateDocumentBody, validateSuggest, validateQuery, parseTaskListQuery, parseJsonOptional, validateRebalance, sendBinary, badRequest, SERVER_CAPABILITIES } from './chunk-CV5H7XL7.mjs';
-export { ASYNC_IMPORT_CAPABILITY, INDEX_LIFECYCLE_CAPABILITY, REBUILD_ANALYSIS_CAPABILITY, SERVER_CAPABILITIES, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, httpStatusForNarsilError } from './chunk-CV5H7XL7.mjs';
-import { validateIndexName } from './chunk-MHE7YWAU.mjs';
-import { engineCoreOf, resolveVectorText } from './chunk-PIWKZPP7.mjs';
-import './chunk-XE6XR2OE.mjs';
+import { DEFAULT_MAX_RETAINED_TASKS, loadUWebSockets, resolveCors, authorizerFor, createSharedGateBuffer, gateSlotOfWorker, createRouteRunner, corsWriter, createSharedRequestGate, MAIN_THREAD_GATE_SLOT, registerServerRoutes, DEFAULT_MAX_CONCURRENT_TASKS, DEFAULT_MAX_TASK_PAGE_SIZE, DEFAULT_MAX_IMPORT_ERRORS, DEFAULT_MAX_FETCH_DOCUMENTS, DEFAULT_MAX_RESULT_WINDOW, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_IMPORT_BATCH_SIZE, DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_IMPORT_BYTES, DEFAULT_MAX_BODY_BYTES, RUNNING_TASK_TTL_MS, DEFAULT_TASK_PAGE_SIZE, TERMINAL_TASK_TTL_MS, TASK_PROGRESS_WRITE_INTERVAL_MS, serializeNarsilError, createVersionHandler, acceptorOf, createDocumentReadHandlers, sendError, respondError, respondJson, MAX_INDEX_TOUCH_INTERVAL_MS, INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT, clearGateSlot, parseJson, validateCreateIndex, rejectInvalid, validateBatch, serializeBatchResult, validateDocumentBody, validateSuggest, validateQuery, parseTaskListQuery, parseJsonOptional, validateRebalance, sendBinary, IMPORT_FLUSHES_IN_FLIGHT, badRequest, SERVER_CAPABILITIES, toHttpError, MIN_UNBOUNDED_SERVER_LIMIT, MIN_COUNTED_SERVER_LIMIT } from './chunk-RGS7FMCB.mjs';
+export { ASYNC_IMPORT_CAPABILITY, INDEX_LIFECYCLE_CAPABILITY, REBUILD_ANALYSIS_CAPABILITY, SERVER_CAPABILITIES, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, httpStatusForNarsilError } from './chunk-RGS7FMCB.mjs';
+import { validateIndexName } from './chunk-NTZYA3SJ.mjs';
+import { engineCoreOf, providedDocId, resolveVectorText } from './chunk-4NVPQ6S5.mjs';
 import { detectRuntime } from './chunk-AV4IJKD2.mjs';
-import './chunk-CBLS46IE.mjs';
-import { NarsilError, ServerErrorCodes, ErrorCodes } from './chunk-P4ELXVJQ.mjs';
-export { ServerErrorCodes } from './chunk-P4ELXVJQ.mjs';
+import './chunk-D2S642IV.mjs';
+import './chunk-L225SHNB.mjs';
+import './chunk-UTOFOJOR.mjs';
+import { startIdleHeapCleanup } from './chunk-Y3L5MDRV.mjs';
+import { NarsilError, ErrorCodes, ServerErrorCodes, isNarsilError } from './chunk-FRQVMFY7.mjs';
+export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, isNarsilError } from './chunk-FRQVMFY7.mjs';
 import { randomUUID } from 'crypto';
 import { MessageChannel } from 'worker_threads';
 
@@ -444,10 +446,7 @@ async function runImport(engine, options) {
     failed += 1;
     if (errors.length < maxErrors) errors.push(error);
   };
-  const flush = async () => {
-    if (pending.length === 0) return;
-    const documents = pending.map((entry) => entry.document);
-    pending = [];
+  const flushDocuments = async (documents) => {
     const result = await engine.insertBatch(indexName, documents, { skipClone: true });
     indexed += result.succeeded.length;
     for (const failure of result.failed) {
@@ -455,36 +454,74 @@ async function runImport(engine, options) {
       recordFailure({ docId: failure.docId, code: serialized.code, message: serialized.message });
     }
   };
+  const inFlight = /* @__PURE__ */ new Set();
+  let flushError;
+  const startFlush = () => {
+    if (pending.length === 0) return;
+    const documents = pending.map((entry) => entry.document);
+    pending = [];
+    const run = flushDocuments(documents).catch((err) => {
+      flushError ??= err;
+    }).finally(() => inFlight.delete(run));
+    inFlight.add(run);
+  };
+  const settleFlushes = async () => {
+    await Promise.all(inFlight);
+    if (flushError !== void 0) throw flushError;
+  };
   const report = () => {
     onProgress?.({ indexed, failed, bytesProcessed, bytesTotal });
   };
-  for (const line of iterateNdjson(body, maxLineBytes)) {
-    bytesProcessed = line.bytesConsumed;
-    let parsed;
-    try {
-      parsed = JSON.parse(line.text);
-    } catch {
-      recordFailure({ line: line.lineNumber, code: ServerErrorCodes.INVALID_JSON, message: "Line is not valid JSON" });
-      continue;
-    }
-    if (!isPlainObject(parsed)) {
-      recordFailure({
-        line: line.lineNumber,
-        code: ServerErrorCodes.INVALID_REQUEST,
-        message: "Line is not a JSON object"
-      });
-      continue;
+  const seenIds = /* @__PURE__ */ new Set();
+  const repeated = [];
+  try {
+    for (const line of iterateNdjson(body, maxLineBytes)) {
+      bytesProcessed = line.bytesConsumed;
+      let parsed;
+      try {
+        parsed = JSON.parse(line.text);
+      } catch {
+        recordFailure({ line: line.lineNumber, code: ServerErrorCodes.INVALID_JSON, message: "Line is not valid JSON" });
+        continue;
+      }
+      if (!isPlainObject(parsed)) {
+        recordFailure({
+          line: line.lineNumber,
+          code: ServerErrorCodes.INVALID_REQUEST,
+          message: "Line is not a JSON object"
+        });
+        continue;
+      }
+      const docId = providedDocId(parsed);
+      if (docId !== void 0) {
+        if (seenIds.has(docId)) {
+          repeated.push({ document: parsed, line: line.lineNumber });
+          continue;
+        }
+        seenIds.add(docId);
+      }
+      pending.push({ document: parsed, line: line.lineNumber });
+      if (pending.length >= batchSize) {
+        signal?.throwIfAborted();
+        startFlush();
+        if (inFlight.size >= IMPORT_FLUSHES_IN_FLIGHT) await Promise.race(inFlight);
+        if (flushError !== void 0) await settleFlushes();
+        report();
+        await yieldToEventLoop();
+        signal?.throwIfAborted();
+      }
     }
-    pending.push({ document: parsed, line: line.lineNumber });
-    if (pending.length >= batchSize) {
-      signal?.throwIfAborted();
-      await flush();
-      report();
-      await yieldToEventLoop();
+    startFlush();
+    await settleFlushes();
+    for (let start = 0; start < repeated.length; start += batchSize) {
       signal?.throwIfAborted();
+      await flushDocuments(repeated.slice(start, start + batchSize).map((entry) => entry.document));
     }
+  } catch (err) {
+    await Promise.allSettled(inFlight);
+    report();
+    throw err;
   }
-  await flush();
   bytesProcessed = bytesTotal;
   report();
   return { indexed, failed, errors, errorsTruncated: failed > errors.length };
@@ -711,12 +748,48 @@ function createSearchHandlers(deps) {
   return { search, preflight, suggest };
 }
 
-// src/server/handlers/version.ts
-function createVersionHandler(deps) {
-  function report(ctx) {
-    respondJson(ctx, { name: "narsil", ...deps.build });
+// src/server/options-validation.ts
+var ENGINE_METHOD_SAMPLE = ["createIndex", "listIndexes", "insert", "query", "get", "shutdown"];
+var LIMITS_UNBOUNDED_AT_ZERO = [
+  "maxBodyBytes",
+  "maxImportBytes",
+  "maxLineBytes",
+  "maxImportErrors",
+  "maxConcurrentRequests",
+  "maxConcurrentTasks"
+];
+var COUNTED_LIMITS = ["importBatchSize", "maxResultWindow", "maxFetchDocuments", "maxTaskPageSize"];
+function assertServerEngine(engine) {
+  const candidate = engine;
+  if (typeof candidate !== "object" || candidate === null) {
+    throw new NarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      "The first argument to createServer must be the engine that createNarsil returns, with the options second",
+      { received: candidate === null ? "null" : typeof candidate }
+    );
   }
-  return { report };
+  const members = candidate;
+  const missing = ENGINE_METHOD_SAMPLE.filter((method) => typeof members[method] !== "function");
+  if (missing.length === 0) return;
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `The first argument to createServer offers no ${missing.join(", ")}, so it is some value other than the engine that createNarsil returns`,
+    { missing }
+  );
+}
+function assertLimit(field, value, minimum) {
+  if (value === void 0) return;
+  if (Number.isInteger(value) && value >= minimum) return;
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `limits.${field} must be a whole number of at least ${minimum}; however, this configuration sets it to ${String(value)}`,
+    { field, value, minimum }
+  );
+}
+function assertServerLimits(limits) {
+  if (limits === void 0) return;
+  for (const field of LIMITS_UNBOUNDED_AT_ZERO) assertLimit(field, limits[field], MIN_UNBOUNDED_SERVER_LIMIT);
+  for (const field of COUNTED_LIMITS) assertLimit(field, limits[field], MIN_COUNTED_SERVER_LIMIT);
 }
 
 // src/server/request-threads/captured-response.ts
@@ -804,7 +877,7 @@ async function answerRequest(handlers, request) {
     params: request.params,
     query: new URLSearchParams(request.query),
     contentType: request.contentType,
-    rawBody: request.rawBody === null ? null : Buffer.from(request.rawBody),
+    rawBody: request.rawBody === null ? null : Buffer.from(request.rawBody.buffer, request.rawBody.byteOffset, request.rawBody.byteLength),
     abort: NO_ABORT,
     hookContext: request.hookContext
   };
@@ -848,8 +921,8 @@ async function answerEmbed(core, request) {
       error: null
     };
   } catch (err) {
-    const error = err instanceof NarsilError ? serializeNarsilError(err) : { code: "INTERNAL_ERROR", message: err instanceof Error ? err.message : String(err) };
-    return { type: "embedded", requestId: request.requestId, value: null, error };
+    if (!isNarsilError(err)) console.warn("Embedding a query for a request thread failed:", err);
+    return { type: "embedded", requestId: request.requestId, value: null, error: toHttpError(err).body };
   }
 }
 function touchIntervalFor(copyIdleTimeoutMs) {
@@ -952,6 +1025,12 @@ async function startRequestThreads(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/server/task-store.ts
 var InMemoryTaskStore = class {
   /**
@@ -1004,7 +1083,7 @@ var InMemoryTaskStore = class {
     if (this.records.size <= this.maxRetained) return;
     for (const [id, record] of this.records) {
       if (this.records.size <= this.maxRetained) break;
-      if (record.status === "succeeded" || record.status === "failed") this.records.delete(id);
+      if (isTerminalTaskStatus(record.status)) this.records.delete(id);
     }
   }
 };
@@ -1081,7 +1160,7 @@ var TaskRegistry = class {
   async cancel(id) {
     const stored = await this.store.get(id);
     if (!stored) return { outcome: "not-found", record: null };
-    if (stored.status !== "running" && stored.status !== "queued") {
+    if (isTerminalTaskStatus(stored.status)) {
       return { outcome: "already-finished", record: stored };
     }
     const task = this.live.get(id);
@@ -1110,7 +1189,7 @@ var TaskRegistry = class {
     }
     for (const record of records) {
       if (record.owner !== this.instanceId) continue;
-      if (record.status !== "running" && record.status !== "queued") continue;
+      if (isTerminalTaskStatus(record.status)) continue;
       const failed = {
         ...record,
         status: "failed",
@@ -1262,7 +1341,10 @@ var NarsilHttpServer = class {
   listenSocket = null;
   ready = false;
   threads = null;
+  stopIdleHeapCleanup = () => void 0;
   constructor(engine, options = {}) {
+    assertServerEngine(engine);
+    assertServerLimits(options.limits);
     this.host = options.host ?? "127.0.0.1";
     this.port = options.port ?? 9876;
     this.options = options;
@@ -1301,10 +1383,13 @@ var NarsilHttpServer = class {
       });
     });
     await this.deps.tasks.reconcile();
+    this.stopIdleHeapCleanup = startIdleHeapCleanup();
     this.ready = true;
   }
   async close() {
     this.ready = false;
+    this.stopIdleHeapCleanup();
+    this.stopIdleHeapCleanup = () => void 0;
     if (this.listenSocket && this.uws) {
       this.uws.us_listen_socket_close(this.listenSocket);
       this.listenSocket = null;
@@ -1315,6 +1400,10 @@ var NarsilHttpServer = class {
       await threads.stop();
     }
   }
+  async shutdown() {
+    await this.close();
+    await this.engine.shutdown();
+  }
   get listeningPort() {
     if (!this.listenSocket || !this.uws) return -1;
     return this.uws.us_socket_local_port(this.listenSocket);
@@ -1336,7 +1425,7 @@ var NarsilHttpServer = class {
       writeCors: cors ? corsWriter(cors) : void 0
     });
     registerServerRoutes(app, run, handlers, limits, cors);
-    if (core === void 0 || !detectRuntime().supportsWorkerThreads) return;
+    if (core === void 0 || threadCount === 0 || !detectRuntime().supportsWorkerThreads) return;
     try {
       this.threads = await startRequestThreads({ core, app, handlers, authorize, gate, limits, build, cors });
     } catch (err) {

package/dist/simd-DW5AtJ6B.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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;
+/**
+ * The distance kernels bound to one memory, which read their operands at byte
+ * offsets inside that memory so that a caller measures against a vector where
+ * it already lies.
+ *
+ * @internal
+ */
+interface ArenaSimd {
+    /** The kernels read every operand out of this memory. */
+    memory: WebAssembly.Memory;
+    /** Returns the dot product of two float32 vectors at the given byte offsets. */
+    dot_product: (ptrA: number, ptrB: number, len: number) => number;
+    /** Returns the length of the float32 vector at the given byte offset. */
+    magnitude: (ptr: number, len: number) => number;
+    /** Returns the squared euclidean distance between two float32 vectors at the given byte offsets. */
+    squared_euclidean_distance: (ptrA: number, ptrB: number, len: number) => number;
+    /** Returns the integer dot product of two byte code vectors at the given byte offsets. */
+    dot_u8: (ptrA: number, ptrB: number, len: number) => number;
+    /** Returns the integer squared distance between two byte code vectors at the given byte offsets. */
+    sqdist_u8: (ptrA: number, ptrB: number, len: number) => number;
+    /** Returns the sum of level products of two 4-bit codes at the given byte offsets, each holding two levels per byte. */
+    osq_dot_nibbles_4x4: (ptrA: number, ptrB: number, bytes: number) => number;
+    /** Returns the sum of level products of a 1-bit or 2-bit code and a query staged as four bit planes. Each plane spans `planeBytes`, with one bit for each of the code's lowest level bits. */
+    osq_dot_bits: (ptrDoc: number, ptrPlanes: number, planeBytes: number, docBits: number) => number;
+    /** Returns the sum of level products of two 1-bit codes or two 2-bit codes at the given byte offsets. */
+    osq_dot_bits_pair: (ptrA: number, ptrB: number, bytes: number, bits: number) => number;
+}
+
+export { type ArenaSimd as A, isSimdAvailable as i };

package/dist/{tasks-DT7L1p6w.d.ts → tasks-Df73Tjgq.d.ts}

@@ -1,4 +1,4 @@
-import { M as MemoryStats } from './memory-Bzd5xcEW.js';
+import { M as MemoryStats } from './memory-xrXOZMbw.js';
 
 /** Declarative index configuration accepted over HTTP. Function-valued engine
  * options (custom tokenizer, stopWords-as-function, group reducer, embedding
@@ -144,12 +144,16 @@ type TaskType = 'optimizeVectors' | 'rebalance' | 'restore' | 'import' | 'rebuil
 /**
  * Where a long-running operation stands.
  *
- * A task reaches `cancelled` only when the work itself stopped early, so a
- * cancel that arrives too late leaves the task `succeeded`.
+ * A task starts `running`, because the server begins the work as it accepts
+ * the request. Where the server already drives
+ * {@link ServerLimits.maxConcurrentTasks} tasks, it answers 429
+ * `TOO_MANY_REQUESTS` and starts none. A task reaches `cancelled` only where
+ * the work itself stops early, so a cancel that arrives too late leaves the
+ * task `succeeded`.
  *
  * @public
  */
-type TaskStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+type TaskStatus = 'running' | 'succeeded' | 'failed' | 'cancelled';
 /**
  * How far a running import has gone, which is what a progress bar reads.
  *
@@ -192,7 +196,7 @@ interface TaskRecord {
     owner: string;
     /** The server accepted the task at this many milliseconds since the epoch. */
     createdAt: number;
-    /** Work started at this many milliseconds since the epoch, and a queued task omits it. */
+    /** Work started at this many milliseconds since the epoch. */
     startedAt?: number;
     /** Work ended at this many milliseconds since the epoch, and a task omits it until it reaches a final status. */
     completedAt?: number;