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

package/dist/thread-PZLEO6JL.mjs

@@ -0,0 +1,310 @@
+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 './chunk-2GWVQWGA.mjs';
+import { ServerErrorCodes, NarsilError, ErrorCodes } from './chunk-P4ELXVJQ.mjs';
+
+// src/server/request-threads/read-engine.ts
+function createThreadReadEngine(options) {
+  const { executor, relay, searchHooks } = options;
+  function requireContext(indexName) {
+    const context = executor.queryContextOf(indexName);
+    if (context === void 0) {
+      throw new NarsilError(ErrorCodes.INDEX_NOT_FOUND, `This thread holds no copy of index "${indexName}"`, {
+        indexName
+      });
+    }
+    relay.touch(indexName);
+    return 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;
+    const context = executor.queryContextOf(indexName);
+    if (context === void 0) return false;
+    const field = params.vector?.field;
+    if (field === void 0) return true;
+    const vectorFields = extractVectorFieldsFromSchema(context.config.schema);
+    if (!vectorFields.has(field)) return true;
+    return context.vectorSearchers.has(field);
+  }
+  return {
+    holdsCopyOf: (indexName) => executor.queryContextOf(indexName) !== void 0,
+    canAnswer,
+    async query(indexName, params) {
+      const context = requireContext(indexName);
+      const result = await executeQuery(await resolvedParams(indexName, params), {
+        manager: context.manager,
+        language: context.language,
+        config: context.config,
+        indexName,
+        cursorBinding: queryBindingOf(params),
+        vectorSearchers: context.vectorSearchers
+      });
+      if (context.analysisStale) result.analysisStale = true;
+      return result;
+    },
+    async preflight(indexName, params) {
+      const context = requireContext(indexName);
+      const result = await executePreflight(await resolvedParams(indexName, params), {
+        manager: context.manager,
+        language: context.language,
+        config: context.config,
+        indexName,
+        cursorBinding: queryBindingOf(params),
+        vectorSearchers: context.vectorSearchers
+      });
+      if (context.analysisStale) result.analysisStale = true;
+      return result;
+    },
+    async suggest(indexName, params) {
+      const context = requireContext(indexName);
+      const result = executeSuggest(context.manager, context.language, params);
+      if (context.analysisStale) result.analysisStale = true;
+      return result;
+    },
+    async get(indexName, docId) {
+      return requireContext(indexName).manager.get(docId);
+    },
+    async getMultiple(indexName, docIds) {
+      const { manager } = requireContext(indexName);
+      const found = /* @__PURE__ */ new Map();
+      for (const docId of docIds) {
+        const document = manager.get(docId);
+        if (document !== void 0) found.set(docId, document);
+      }
+      return found;
+    },
+    async has(indexName, docId) {
+      return requireContext(indexName).manager.has(docId);
+    },
+    async countDocuments(indexName) {
+      return requireContext(indexName).manager.countDocuments();
+    },
+    async listDocuments(indexName, params) {
+      const context = requireContext(indexName);
+      return executeListDocuments(params ?? {}, { manager: context.manager, schema: context.config.schema });
+    }
+  };
+}
+
+// src/server/request-threads/relay-client.ts
+function isRelayReply(message) {
+  if (typeof message !== "object" || message === null) return false;
+  const { type, requestId } = message;
+  return typeof requestId === "number" && (type === "response" || type === "authorized" || type === "embedded");
+}
+function errorOf(reply) {
+  const error = reply.error ?? { code: ErrorCodes.EMBEDDING_FAILED, message: "The main thread returned no vector" };
+  return new NarsilError(error.code, error.message, error.details);
+}
+function portClosedError() {
+  return new NarsilError(ErrorCodes.WORKER_CRASHED, "The port to the main thread closed before it answered");
+}
+var SHUTTING_DOWN_DENIAL = {
+  allowed: false,
+  denial: { status: 503, code: ServerErrorCodes.INTERNAL_ERROR, message: "The server is shutting down" }
+};
+function sendUnavailable(res) {
+  sendError(res, 503, ServerErrorCodes.INTERNAL_ERROR, "The server is shutting down");
+}
+function createRelayClient(port, touchIntervalMs) {
+  const pending = /* @__PURE__ */ new Map();
+  const touchedAt = /* @__PURE__ */ new Map();
+  let nextRequestId = 0;
+  let closed = false;
+  function failAll() {
+    closed = true;
+    const waiting = [...pending.values()];
+    pending.clear();
+    for (const entry of waiting) entry.reject(portClosedError());
+  }
+  port.on("message", (message) => {
+    if (!isRelayReply(message)) return;
+    const waiting = pending.get(message.requestId);
+    if (waiting === void 0) return;
+    pending.delete(message.requestId);
+    waiting.resolve(message);
+  });
+  port.on("close", failAll);
+  function send(build) {
+    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));
+    });
+  }
+  return {
+    async authorize(context) {
+      let reply;
+      try {
+        reply = await send((requestId) => ({ type: "authorize", requestId, context }));
+      } catch {
+        return SHUTTING_DOWN_DENIAL;
+      }
+      if (reply.type !== "authorized") return { allowed: false, denial: null };
+      if (reply.hookError) return { allowed: false, denial: null };
+      if (reply.denial !== null) return { allowed: false, denial: reply.denial };
+      return { allowed: true };
+    },
+    async request(route, ctx) {
+      let reply;
+      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
+        }));
+      } catch {
+        if (!ctx.abort.aborted) sendUnavailable(ctx.res);
+        return;
+      }
+      if (reply.type !== "response" || ctx.abort.aborted) return;
+      sendRelayed(ctx.res, ctx.abort, reply.status, reply.headers, reply.body);
+    },
+    async embed(indexName, vector) {
+      const reply = await send((requestId) => ({ type: "embed", requestId, indexName, vector }));
+      if (reply.type !== "embedded" || reply.value === null) {
+        throw reply.type === "embedded" ? errorOf(reply) : new NarsilError(ErrorCodes.EMBEDDING_FAILED, "The main thread returned no vector");
+      }
+      return reply.value;
+    },
+    touch(indexName) {
+      if (closed) return;
+      const now = Date.now();
+      const last = touchedAt.get(indexName);
+      if (last !== void 0 && now - last < touchIntervalMs) return;
+      touchedAt.set(indexName, now);
+      port.postMessage({ type: "touch", indexName });
+    },
+    close() {
+      failAll();
+      port.close();
+    }
+  };
+}
+
+// src/server/request-threads/thread.ts
+var servingApp = null;
+function relayed(relay, route) {
+  return (ctx) => relay.request(route, ctx);
+}
+function onHeldIndex(local, handler, fallback) {
+  return (ctx) => local.holdsCopyOf(ctx.params[0]) ? handler(ctx) : fallback(ctx);
+}
+function searchHandler(local, fallback, maxResultWindow, answer) {
+  return async (ctx) => {
+    const params = parseJson(ctx);
+    if (!params) return;
+    const failure = validateQuery(params, maxResultWindow);
+    if (failure) {
+      rejectInvalid(ctx, failure);
+      return;
+    }
+    if (!local.canAnswer(ctx.params[0], params)) {
+      await fallback(ctx);
+      return;
+    }
+    try {
+      respondJson(ctx, await answer(ctx.params[0], params));
+    } catch (err) {
+      respondError(ctx, err);
+    }
+  };
+}
+function suggestHandler(local, fallback) {
+  return async (ctx) => {
+    const params = parseJson(ctx);
+    if (!params) return;
+    const failure = validateSuggest(params);
+    if (failure) {
+      rejectInvalid(ctx, failure);
+      return;
+    }
+    if (!local.holdsCopyOf(ctx.params[0])) {
+      await fallback(ctx);
+      return;
+    }
+    try {
+      respondJson(ctx, await local.suggest(ctx.params[0], params));
+    } catch (err) {
+      respondError(ctx, err);
+    }
+  };
+}
+var THREAD_ONLY_ROUTES = /* @__PURE__ */ new Set(["livez", "version", "capabilities"]);
+function isRelayedRoute(handler) {
+  return !THREAD_ONLY_ROUTES.has(handler);
+}
+function relayedHandlers(relay, limits) {
+  const forwarded = {};
+  for (const route of serverRoutes(limits)) {
+    if (isRelayedRoute(route.handler)) forwarded[route.handler] = relayed(relay, route.handler);
+  }
+  return forwarded;
+}
+function threadHandlers(local, relay, settings) {
+  const reads = createDocumentReadHandlers({ engine: local, limits: settings.limits });
+  const forwarded = relayedHandlers(relay, settings.limits);
+  const { maxResultWindow } = settings.limits;
+  return {
+    ...forwarded,
+    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,
+      maxResultWindow,
+      (name, params) => local.preflight(name, params)
+    ),
+    suggest: suggestHandler(local, forwarded.suggest),
+    get: onHeldIndex(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)
+  };
+}
+async function serveRequests(executor, settings) {
+  if (servingApp !== null) throw new Error("This worker already serves requests");
+  const uws = await loadUWebSockets();
+  const app = uws.App();
+  const child = childAppOf(app);
+  if (child === null) throw new Error("This uWebSockets.js build offers no child apps");
+  const relay = createRelayClient(settings.port, settings.touchIntervalMs);
+  const local = createThreadReadEngine({ executor, relay, searchHooks: settings.searchHooks });
+  const run = createRouteRunner({
+    authorize: settings.authorizes ? (context) => relay.authorize(context) : void 0,
+    gate: createSharedRequestGate(settings.gate, settings.maxConcurrentRequests, settings.gateSlot),
+    writeCors: settings.cors ? corsWriter(settings.cors) : void 0
+  });
+  registerServerRoutes(app, run, threadHandlers(local, relay, settings), settings.limits, settings.cors);
+  servingApp = { app: child, relay };
+  return { descriptor: child.getDescriptor() };
+}
+function closeRequestThread() {
+  if (servingApp === null) return;
+  const { app, relay } = servingApp;
+  servingApp = null;
+  app.close();
+  relay.close();
+}
+
+export { closeRequestThread, serveRequests };

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

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

package/dist/vector/hnsw-build-worker.mjs

@@ -1,4 +1,5 @@
-import { createVectorStore, createHNSWIndex, MAX_WORKER_DIMENSION, MAX_WORKER_VECTORS } from '../chunk-JXHUHFJ5.mjs';
+import { createVectorStore, createHNSWIndex, MAX_WORKER_DIMENSION, MAX_WORKER_VECTORS } from '../chunk-X6YZO4MQ.mjs';
+import '../chunk-RP23PWMV.mjs';
 import '../chunk-2GWVQWGA.mjs';
 
 // src/vector/hnsw-build-worker.ts

package/dist/vector/search-worker.mjs

@@ -1,126 +1,8 @@
-import { createScalarQuantizer, deriveSq8Constants, arenaQuantizedDistance, quantizeVectorInto, quantizedMagnitude, scalarQuantizedDistance } from '../chunk-HGJC5L65.mjs';
-import { searchOrdinals, MAX_WORKER_COPIES, createVectorStore, createHNSWIndex, createSharedArenaSimd, importAdjacency, createHNSWWorkspace, arenaFloat32Distance, ABSENT_DOCUMENT_RANK } from '../chunk-JXHUHFJ5.mjs';
+import { openSharedWorkerCopy, createScalarQuantizer } from '../chunk-PMBHH44R.mjs';
+import { searchOrdinals, MAX_WORKER_COPIES, createVectorStore, createHNSWIndex } from '../chunk-X6YZO4MQ.mjs';
+import '../chunk-RP23PWMV.mjs';
 import '../chunk-2GWVQWGA.mjs';
 
-// src/vector/shared-generation/worker-view.ts
-function createVectorReader(snapshot, simd, scratchSlot) {
-  const { layout, magnitudes, rankByOrdinal } = snapshot;
-  const { dimension, slots } = layout;
-  const vectors = new Float32Array(snapshot.memory.buffer, layout.vectorsOffset, slots * dimension);
-  const scratchByteOffset = scratchSlot * layout.float32ScratchStride;
-  const scratch = simd ? new Float32Array(snapshot.memory.buffer, scratchByteOffset, dimension) : null;
-  const holdsDocument = (ordinal) => ordinal >= 0 && ordinal < slots && rankByOrdinal[ordinal] !== ABSENT_DOCUMENT_RANK;
-  return {
-    entryForOrdinal(ordinal) {
-      if (!holdsDocument(ordinal)) return void 0;
-      const base = ordinal * dimension;
-      return { vector: vectors.subarray(base, base + dimension), magnitude: magnitudes[ordinal] };
-    },
-    prepareQueryArena(query) {
-      if (!simd || !scratch || query.length !== dimension) return null;
-      scratch.set(query, 0);
-      return { magnitude: simd.magnitude(scratchByteOffset, dimension) };
-    },
-    distanceFromArena(prepared, ordinal, metric) {
-      if (!simd || !holdsDocument(ordinal)) return Number.POSITIVE_INFINITY;
-      const byteOffset = layout.vectorsOffset + ordinal * dimension * 4;
-      return arenaFloat32Distance(
-        simd,
-        scratchByteOffset,
-        byteOffset,
-        dimension,
-        metric,
-        prepared.magnitude,
-        magnitudes[ordinal]
-      );
-    }
-  };
-}
-function createQuantizerReader(snapshot, simd, scratchSlot) {
-  if (snapshot.quantization !== "sq8" || snapshot.calibration === null) return void 0;
-  const { layout, codeSums, codeMagnitudes, codePresent } = snapshot;
-  const { dimension, slots } = layout;
-  const constants = deriveSq8Constants(snapshot.calibration.alpha, snapshot.calibration.offset, dimension);
-  const codes = new Uint8Array(snapshot.memory.buffer, layout.codesOffset, slots * dimension);
-  const scratchByteOffset = layout.codeScratchOffset + scratchSlot * layout.codeScratchStride;
-  const scratch = simd ? new Uint8Array(snapshot.memory.buffer, scratchByteOffset, dimension) : null;
-  let liveCodes = 0;
-  for (let ordinal = 0; ordinal < codePresent.length; ordinal++) {
-    if (codePresent[ordinal] === 1) liveCodes++;
-  }
-  const holdsCodes = (ordinal) => ordinal >= 0 && ordinal < slots && codePresent[ordinal] === 1;
-  return {
-    get size() {
-      return liveCodes;
-    },
-    isCalibrated: () => true,
-    prepareQuery(query) {
-      const quantized = new Uint8Array(dimension);
-      const { sum, sumSq } = quantizeVectorInto(quantized, query, dimension, constants);
-      return { quantized, sum, sumSq, magnitude: quantizedMagnitude(constants, sumSq, sum) };
-    },
-    distanceFromPreparedByOrdinal(prepared, ordinal, metric) {
-      if (!holdsCodes(ordinal)) return Number.POSITIVE_INFINITY;
-      return scalarQuantizedDistance(
-        codes,
-        codeSums,
-        codeMagnitudes,
-        dimension,
-        constants,
-        prepared.quantized,
-        prepared.sum,
-        prepared.magnitude,
-        ordinal,
-        metric
-      );
-    },
-    prepareQueryArena(query) {
-      if (!simd || !scratch) return null;
-      const { sum, sumSq } = quantizeVectorInto(scratch, query, dimension, constants);
-      return { sum, sumSq, magnitude: quantizedMagnitude(constants, sumSq, sum) };
-    },
-    distanceFromArena(prepared, ordinal, metric) {
-      if (!simd || !holdsCodes(ordinal)) return Number.POSITIVE_INFINITY;
-      return arenaQuantizedDistance(
-        simd,
-        scratchByteOffset,
-        layout.codesOffset + ordinal * dimension,
-        dimension,
-        constants,
-        prepared.sum,
-        prepared.magnitude,
-        codeSums[ordinal],
-        codeMagnitudes[ordinal],
-        metric
-      );
-    }
-  };
-}
-function openSharedWorkerCopy(snapshot, scratchSlot) {
-  if (scratchSlot < 0 || scratchSlot >= snapshot.layout.workerSlots) {
-    throw new Error(`Scratch slot ${scratchSlot} is outside the ${snapshot.layout.workerSlots} reserved slots`);
-  }
-  const simd = createSharedArenaSimd(snapshot.memory);
-  const adjacency = importAdjacency(snapshot.graph.adjacency);
-  const capacity = Math.max(snapshot.graph.capacity, adjacency.capacity);
-  const searchState = {
-    dimension: snapshot.dimension,
-    store: createVectorReader(snapshot, simd, scratchSlot),
-    quantizer: createQuantizerReader(snapshot, simd, scratchSlot),
-    adjacency,
-    tombstones: snapshot.graph.tombstones,
-    tombstoneCount: snapshot.graph.tombstoneCount,
-    nodeCount: snapshot.graph.nodeCount,
-    capacity,
-    visited: new Uint32Array(capacity),
-    visitStamp: 0,
-    entryPointOrd: snapshot.graph.entryPointOrd,
-    topLayer: snapshot.graph.topLayer,
-    workspace: createHNSWWorkspace()
-  };
-  return { searchState, rankByOrdinal: snapshot.rankByOrdinal };
-}
-
 // src/vector/worker-copy.ts
 function restoreWorkerCopy(snapshot) {
   const store = createVectorStore();

package/dist/workers/entry.mjs

@@ -1,4 +1,4 @@
-import { isValidWorkerAction } from '../chunk-RDGXYRF4.mjs';
+import { isValidWorkerAction } from '../chunk-WYJXSLER.mjs';
 import { NarsilError, ErrorCodes } from '../chunk-P4ELXVJQ.mjs';
 
 // src/workers/action-handler.ts
@@ -16,9 +16,24 @@ async function importBootstrapModule(moduleUrl) {
   }
   await import(moduleUrl);
 }
+async function stopServingRequests() {
+  const { closeRequestThread } = await import('../thread-PZLEO6JL.mjs');
+  closeRequestThread();
+}
+function holdsCopies(executor) {
+  return typeof executor.queryContextOf === "function";
+}
 function createActionHandler(executor) {
+  let servingRequests = false;
+  const serving = { start: null };
+  async function stopServingOnceStarted() {
+    if (serving.start !== null) await serving.start;
+    if (servingRequests) await stopServingRequests();
+    servingRequests = false;
+  }
   return async function handleAction(action, post) {
     if (action.type === "shutdown") {
+      await stopServingOnceStarted();
       await executor.shutdown();
       post(buildSuccessResponse(action.requestId, void 0));
       return true;
@@ -29,6 +44,28 @@ function createActionHandler(executor) {
         post(buildSuccessResponse(action.requestId, void 0));
         return false;
       }
+      if (action.type === "serveRequests") {
+        if (!holdsCopies(executor)) {
+          throw new NarsilError(ErrorCodes.CONFIG_INVALID, "This executor holds no copies to answer requests from");
+        }
+        const starting = import('../thread-PZLEO6JL.mjs').then(
+          ({ serveRequests }) => serveRequests(executor, action.settings)
+        );
+        serving.start = starting.then(
+          () => {
+            servingRequests = true;
+          },
+          () => void 0
+        );
+        const result2 = await starting;
+        post(buildSuccessResponse(action.requestId, result2));
+        return false;
+      }
+      if (action.type === "stopServing") {
+        await stopServingOnceStarted();
+        post(buildSuccessResponse(action.requestId, void 0));
+        return false;
+      }
       const result = await executor.execute(action);
       post(buildSuccessResponse(action.requestId, result));
     } catch (err) {
@@ -47,16 +84,23 @@ function startWorker() {
   });
 }
 startWorker();
+function workerIdOf(workerData) {
+  if (typeof workerData !== "object" || workerData === null) return void 0;
+  const workerId = workerData.workerId;
+  return typeof workerId === "number" ? workerId : void 0;
+}
 async function setup() {
   let parentPort = null;
+  let scratchSlot;
   try {
     const workerThreads = await import('worker_threads');
     parentPort = workerThreads.parentPort ?? null;
+    scratchSlot = workerIdOf(workerThreads.workerData);
   } catch {
     parentPort = null;
   }
-  const { createDirectExecutor } = await import('../direct-executor-HRTDWMVB.mjs');
-  const handleAction = createActionHandler(createDirectExecutor());
+  const { createDirectExecutor } = await import('../direct-executor-OREXU72C.mjs');
+  const handleAction = createActionHandler(createDirectExecutor({ scratchSlot }));
   if (parentPort) {
     const port = parentPort;
     port.on("message", (raw) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delali/narsil",
-  "version": "0.2.4-next.49",
+  "version": "0.2.4-next.50",
   "type": "module",
   "description": "A distributed full-text search engine with cross-language portable binary format.",
   "author": "Delali (https://sondelali.com)",
@@ -30,6 +30,10 @@
     "#platform/node-worker": {
       "browser": "./src/workers/node-worker.browser.ts",
       "default": "./src/workers/node-worker.ts"
+    },
+    "#platform/heap-statistics": {
+      "browser": "./src/runtime/heap-statistics.browser.ts",
+      "default": "./src/runtime/heap-statistics.ts"
     }
   },
   "sideEffects": false,

package/dist/direct-executor-HRTDWMVB.mjs

@@ -1,9 +0,0 @@
-export { createDirectExecutor } from './chunk-M6JGMKA5.mjs';
-import './chunk-CBLS46IE.mjs';
-import './chunk-TGP5M5R7.mjs';
-import './chunk-HGJC5L65.mjs';
-import './chunk-JXHUHFJ5.mjs';
-import './chunk-U2BKYEC7.mjs';
-import './chunk-2GWVQWGA.mjs';
-import './chunk-RDGXYRF4.mjs';
-import './chunk-P4ELXVJQ.mjs';