@delali/narsil 0.2.4-next.50 → 0.2.4-next.52

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-Bn4R1NPN.d.ts → tasks-DiF1c9v2.d.ts}

@@ -1,3 +1,5 @@
+import { M as MemoryStats } from './memory-OmgkX_Z2.js';
+
 /** Declarative index configuration accepted over HTTP. Function-valued engine
  * options (custom tokenizer, stopWords-as-function, group reducer, embedding
  * adapter object) are not representable here; the embedding adapter is named
@@ -115,6 +117,23 @@ interface CapabilitiesResponse {
     /** Each name marks one capability this server serves. */
     capabilities: string[];
 }
+/**
+ * The body `GET /stats/memory` answers with, which is the engine's {@link MemoryStats}
+ * plus the number of worker threads the server receives requests on. Only the
+ * server can report that count, because it starts those threads.
+ *
+ * @public
+ */
+interface MemoryStatsResponse extends MemoryStats {
+    /**
+     * This many worker threads receive requests and answer searches from the
+     * copies they hold. The count is zero where the main thread answers everything
+     * itself, which happens under `workers.enabled: false`, on a runtime without
+     * worker threads, and on a cluster node's engine. See
+     * {@link NarsilServer.requestThreadCount}.
+     */
+    requestThreads: number;
+}
 
 /**
  * Which long-running operation a task record tracks.
@@ -271,4 +290,4 @@ interface TaskStore {
     shutdown?(): Promise<void>;
 }
 
-export type { CapabilitiesResponse as C, HttpIndexConfig as H, ImportError as I, TaskListPage as T, CreateIndexEmbedding as a, ImportResult as b, TaskListQuery as c, TaskProgress as d, TaskRecord as e, TaskStatus as f, TaskType as g, TaskStore as h, CreateIndexRequest as i };
+export type { CapabilitiesResponse as C, HttpIndexConfig as H, ImportError as I, MemoryStatsResponse as M, TaskListPage as T, CreateIndexEmbedding as a, ImportResult as b, TaskListQuery as c, TaskProgress as d, TaskRecord as e, TaskStatus as f, TaskType as g, TaskStore as h, CreateIndexRequest as i };

package/dist/{thread-PZLEO6JL.mjs → thread-TLCX43WV.mjs}

@@ -1,15 +1,56 @@
-import { loadUWebSockets, childAppOf, createRouteRunner, corsWriter, createSharedRequestGate, registerServerRoutes, sendRelayed, createDocumentReadHandlers, respondJson, SERVER_CAPABILITIES, sendError, serverRoutes, parseJson, validateSuggest, rejectInvalid, respondError, validateQuery } from './chunk-CV5H7XL7.mjs';
-import { executeListDocuments, executeSuggest, executePreflight, queryBindingOf, executeQuery } from './chunk-ZHUQKZBE.mjs';
-import './chunk-XE6XR2OE.mjs';
-import { extractVectorFieldsFromSchema } from './chunk-CMVG2UEF.mjs';
-import './chunk-CBLS46IE.mjs';
-import './chunk-RP23PWMV.mjs';
+import { loadUWebSockets, childAppOf, createRouteRunner, corsWriter, createSharedRequestGate, registerServerRoutes, sendRelayed, createDocumentReadHandlers, respondJson, SERVER_CAPABILITIES, sendError, serverRoutes, parseJson, validateSuggest, rejectInvalid, respondError, validateQuery } from './chunk-EY2ULUMT.mjs';
+import { executeListDocuments, executeSuggest, executePreflight, queryBindingOf, executeQuery } from './chunk-YPYULM5E.mjs';
+import './chunk-3GWP2TO6.mjs';
+import { resolveProjection, projectionKeepsField, setNestedValue } from './chunk-WM7IS45M.mjs';
+import { extractVectorFieldsFromSchema } from './chunk-ZT5BRDFW.mjs';
+import './chunk-ZJ4CSAB2.mjs';
+import './chunk-WFKIGEBY.mjs';
 import './chunk-2GWVQWGA.mjs';
 import { ServerErrorCodes, NarsilError, ErrorCodes } from './chunk-P4ELXVJQ.mjs';
 
+// src/server/request-threads/held-vectors.ts
+function managerWithHeldVectors(manager, fieldPaths, vectorOf) {
+  function get(docId, projection) {
+    const document = manager.get(docId, projection);
+    if (document === void 0) return void 0;
+    for (const fieldPath of fieldPaths) {
+      if (projection !== void 0 && !projectionKeepsField(projection, fieldPath)) continue;
+      const vector = vectorOf(fieldPath, docId);
+      if (vector !== void 0)
+        setNestedValue(document, fieldPath, Float32Array.from(vector));
+    }
+    return document;
+  }
+  const reader = Object.create(manager);
+  reader.get = get;
+  return reader;
+}
+
 // src/server/request-threads/read-engine.ts
 function createThreadReadEngine(options) {
   const { executor, relay, searchHooks } = options;
+  function vectorFieldsOf(context) {
+    return [...extractVectorFieldsFromSchema(context.config.schema).keys()];
+  }
+  function holdsEveryVectorField(indexName, context) {
+    return vectorFieldsOf(context).every((fieldPath) => executor.holdsVectorField(indexName, fieldPath));
+  }
+  function holdsEveryVectorFieldRead(indexName, context, params) {
+    if (params.document === false) return true;
+    const projection = resolveProjection(params.document === true ? void 0 : params.document);
+    return vectorFieldsOf(context).every(
+      (fieldPath) => !projectionKeepsField(projection, fieldPath) || executor.holdsVectorField(indexName, fieldPath)
+    );
+  }
+  function managerOf(indexName, context) {
+    const fieldPaths = vectorFieldsOf(context);
+    if (fieldPaths.length === 0) return context.manager;
+    return managerWithHeldVectors(
+      context.manager,
+      fieldPaths,
+      (fieldPath, docId) => executor.heldVectorOf(indexName, fieldPath, docId)
+    );
+  }
   function requireContext(indexName) {
     const context = executor.queryContextOf(indexName);
     if (context === void 0) {
@@ -20,29 +61,51 @@ function createThreadReadEngine(options) {
     relay.touch(indexName);
     return context;
   }
+  function requireWholeDocuments(indexName) {
+    const context = requireContext(indexName);
+    if (!holdsEveryVectorField(indexName, context)) {
+      throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `This thread holds no vectors of index "${indexName}" yet`, {
+        indexName
+      });
+    }
+    return { context, manager: managerOf(indexName, context) };
+  }
   async function resolvedParams(indexName, params) {
     if (params.vector?.text === void 0) return params;
     const value = await relay.embed(indexName, params.vector);
     const { text: _text, ...vector } = params.vector;
     return { ...params, vector: { ...vector, value } };
   }
-  function canAnswer(indexName, params) {
-    if (searchHooks) return false;
+  function holdsDocumentsOf(indexName) {
     const context = executor.queryContextOf(indexName);
-    if (context === void 0) return false;
+    return context !== void 0 && holdsEveryVectorField(indexName, context);
+  }
+  function searchableContext(indexName, params) {
+    if (searchHooks) return null;
+    const context = executor.queryContextOf(indexName);
+    if (context === void 0) return null;
     const field = params.vector?.field;
-    if (field === void 0) return true;
+    if (field === void 0) return context;
     const vectorFields = extractVectorFieldsFromSchema(context.config.schema);
-    if (!vectorFields.has(field)) return true;
-    return context.vectorSearchers.has(field);
+    if (!vectorFields.has(field)) return context;
+    return context.vectorSearchers.has(field) ? context : null;
+  }
+  function canAnswer(indexName, params) {
+    const context = searchableContext(indexName, params);
+    return context !== null && holdsEveryVectorFieldRead(indexName, context, params);
+  }
+  function canCount(indexName, params) {
+    return searchableContext(indexName, params) !== null;
   }
   return {
     holdsCopyOf: (indexName) => executor.queryContextOf(indexName) !== void 0,
+    holdsDocumentsOf,
     canAnswer,
+    canCount,
     async query(indexName, params) {
-      const context = requireContext(indexName);
+      const { context, manager } = requireWholeDocuments(indexName);
       const result = await executeQuery(await resolvedParams(indexName, params), {
-        manager: context.manager,
+        manager,
         language: context.language,
         config: context.config,
         indexName,
@@ -72,10 +135,10 @@ function createThreadReadEngine(options) {
       return result;
     },
     async get(indexName, docId) {
-      return requireContext(indexName).manager.get(docId);
+      return requireWholeDocuments(indexName).manager.get(docId);
     },
     async getMultiple(indexName, docIds) {
-      const { manager } = requireContext(indexName);
+      const { manager } = requireWholeDocuments(indexName);
       const found = /* @__PURE__ */ new Map();
       for (const docId of docIds) {
         const document = manager.get(docId);
@@ -90,8 +153,8 @@ function createThreadReadEngine(options) {
       return requireContext(indexName).manager.countDocuments();
     },
     async listDocuments(indexName, params) {
-      const context = requireContext(indexName);
-      return executeListDocuments(params ?? {}, { manager: context.manager, schema: context.config.schema });
+      const { context, manager } = requireWholeDocuments(indexName);
+      return executeListDocuments(params ?? {}, { manager, schema: context.config.schema });
     }
   };
 }
@@ -113,6 +176,13 @@ var SHUTTING_DOWN_DENIAL = {
   allowed: false,
   denial: { status: 503, code: ServerErrorCodes.INTERNAL_ERROR, message: "The server is shutting down" }
 };
+function relayedBody(rawBody) {
+  if (rawBody === null) return { bytes: null, moved: [] };
+  const memory = rawBody.buffer;
+  const ownsItsMemory = memory instanceof ArrayBuffer && rawBody.byteOffset === 0 && rawBody.byteLength === memory.byteLength;
+  if (!ownsItsMemory) return { bytes: new Uint8Array(rawBody), moved: [] };
+  return { bytes: new Uint8Array(memory), moved: [memory] };
+}
 function sendUnavailable(res) {
   sendError(res, 503, ServerErrorCodes.INTERNAL_ERROR, "The server is shutting down");
 }
@@ -135,13 +205,18 @@ function createRelayClient(port, touchIntervalMs) {
     waiting.resolve(message);
   });
   port.on("close", failAll);
-  function send(build) {
+  function send(build, moved = []) {
     if (closed) return Promise.reject(portClosedError());
     nextRequestId += 1;
     const requestId = nextRequestId;
     return new Promise((resolve, reject) => {
       pending.set(requestId, { resolve, reject });
-      port.postMessage(build(requestId));
+      try {
+        port.postMessage(build(requestId), moved);
+      } catch (err) {
+        pending.delete(requestId);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
     });
   }
   return {
@@ -159,17 +234,21 @@ function createRelayClient(port, touchIntervalMs) {
     },
     async request(route, ctx) {
       let reply;
+      const body = relayedBody(ctx.rawBody);
       try {
-        reply = await send((requestId) => ({
-          type: "request",
-          requestId,
-          route,
-          params: ctx.params,
-          query: ctx.query.toString(),
-          contentType: ctx.contentType,
-          rawBody: ctx.rawBody === null ? null : new Uint8Array(ctx.rawBody),
-          hookContext: ctx.hookContext
-        }));
+        reply = await send(
+          (requestId) => ({
+            type: "request",
+            requestId,
+            route,
+            params: ctx.params,
+            query: ctx.query.toString(),
+            contentType: ctx.contentType,
+            rawBody: body.bytes,
+            hookContext: ctx.hookContext
+          }),
+          body.moved
+        );
       } catch {
         if (!ctx.abort.aborted) sendUnavailable(ctx.res);
         return;
@@ -207,7 +286,11 @@ function relayed(relay, route) {
 function onHeldIndex(local, handler, fallback) {
   return (ctx) => local.holdsCopyOf(ctx.params[0]) ? handler(ctx) : fallback(ctx);
 }
-function searchHandler(local, fallback, maxResultWindow, answer) {
+function onWholeDocuments(local, handler, fallback) {
+  return (ctx) => local.holdsDocumentsOf(ctx.params[0]) ? handler(ctx) : fallback(ctx);
+}
+function searchHandler(options) {
+  const { fallback, maxResultWindow, staysOnThread, answer } = options;
   return async (ctx) => {
     const params = parseJson(ctx);
     if (!params) return;
@@ -216,7 +299,7 @@ function searchHandler(local, fallback, maxResultWindow, answer) {
       rejectInvalid(ctx, failure);
       return;
     }
-    if (!local.canAnswer(ctx.params[0], params)) {
+    if (!staysOnThread(ctx.params[0], params)) {
       await fallback(ctx);
       return;
     }
@@ -267,19 +350,24 @@ function threadHandlers(local, relay, settings) {
     livez: (ctx) => respondJson(ctx, { status: "ok" }),
     version: (ctx) => respondJson(ctx, { name: "narsil", ...settings.build }),
     capabilities: (ctx) => respondJson(ctx, { capabilities: [...SERVER_CAPABILITIES] }),
-    search: searchHandler(local, forwarded.search, maxResultWindow, (name, params) => local.query(name, params)),
-    preflight: searchHandler(
-      local,
-      forwarded.preflight,
+    search: searchHandler({
+      fallback: forwarded.search,
+      maxResultWindow,
+      staysOnThread: (name, params) => local.canAnswer(name, params),
+      answer: (name, params) => local.query(name, params)
+    }),
+    preflight: searchHandler({
+      fallback: forwarded.preflight,
       maxResultWindow,
-      (name, params) => local.preflight(name, params)
-    ),
+      staysOnThread: (name, params) => local.canCount(name, params),
+      answer: (name, params) => local.preflight(name, params)
+    }),
     suggest: suggestHandler(local, forwarded.suggest),
-    get: onHeldIndex(local, reads.get, forwarded.get),
+    get: onWholeDocuments(local, reads.get, forwarded.get),
     exists: onHeldIndex(local, reads.exists, forwarded.exists),
     count: onHeldIndex(local, reads.count, forwarded.count),
-    list: onHeldIndex(local, reads.list, forwarded.list),
-    multiGet: onHeldIndex(local, reads.multiGet, forwarded.multiGet)
+    list: onWholeDocuments(local, reads.list, forwarded.list),
+    multiGet: onWholeDocuments(local, reads.multiGet, forwarded.multiGet)
   };
 }
 async function serveRequests(executor, settings) {

package/dist/{types-DXPxaXPO.d.ts → types-LEzMyjVX.d.ts}

@@ -1,4 +1,4 @@
-import { S as SchemaDefinition } from './schema-BqRx9t4E.js';
+import { S as SchemaDefinition } from './schema-OSWaaZzx.js';
 
 /**
  * What a node does in a cluster. A node may hold several roles at once.