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

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

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

@@ -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.51",
   "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';