@delali/narsil 0.2.4-next.51 → 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-DT7L1p6w.d.ts → tasks-DiF1c9v2.d.ts}

@@ -1,4 +1,4 @@
-import { M as MemoryStats } from './memory-Bzd5xcEW.js';
+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

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.