@delali/narsil 0.3.1-next.70 → 0.3.1-next.72

package/dist/react.mjs

@@ -1,4 +1,4 @@
-import { createContext, useState, useEffect, createElement, useRef, useEffectEvent, useCallback, useMemo, useContext, useSyncExternalStore } from 'react';
+import { createContext, useState, createElement, useRef, useEffectEvent, useEffect, useCallback, useMemo, useContext, useSyncExternalStore } from 'react';
 
 // src/errors.ts
 var NARSIL_ERROR_MARKER = /* @__PURE__ */ Symbol.for("@delali/narsil.NarsilError");
@@ -33,6 +33,7 @@ var ErrorCodes = {
   SEARCH_INVALID_MODE: "SEARCH_INVALID_MODE",
   SEARCH_INVALID_CURSOR: "SEARCH_INVALID_CURSOR",
   SEARCH_RESULT_WINDOW_EXCEEDED: "SEARCH_RESULT_WINDOW_EXCEEDED",
+  SEARCH_WORK_CAP_EXCEEDED: "SEARCH_WORK_CAP_EXCEEDED",
   LANGUAGE_NOT_SUPPORTED: "LANGUAGE_NOT_SUPPORTED",
   ENVELOPE_VERSION_MISMATCH: "ENVELOPE_VERSION_MISMATCH",
   ENVELOPE_INVALID_MAGIC: "ENVELOPE_INVALID_MAGIC",
@@ -147,8 +148,53 @@ function isNarsilError(value) {
   return typeof value === "object" && value !== null && NARSIL_ERROR_MARKER in value;
 }
 
+// src/react/reader.ts
+function plainNumbersIn(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (ArrayBuffer.isView(value)) {
+    return value instanceof DataView ? value : Array.from(value);
+  }
+  if (Array.isArray(value)) {
+    let copy2 = null;
+    for (let at = 0; at < value.length; at++) {
+      const converted = plainNumbersIn(value[at]);
+      if (converted === value[at]) continue;
+      copy2 ??= value.slice();
+      copy2[at] = converted;
+    }
+    return copy2 ?? value;
+  }
+  let copy = null;
+  for (const [key, held] of Object.entries(value)) {
+    const converted = plainNumbersIn(held);
+    if (converted === held) continue;
+    copy ??= { ...value };
+    copy[key] = converted;
+  }
+  return copy ?? value;
+}
+function withPlainNumbers(answer) {
+  return answer.then((value) => plainNumbersIn(value));
+}
+function engineReader(engine) {
+  return {
+    query(indexName, params) {
+      return withPlainNumbers(engine.query(indexName, params));
+    },
+    preflight: (indexName, params) => engine.preflight(indexName, params),
+    suggest: (indexName, params) => engine.suggest(indexName, params),
+    get: (indexName, docId) => withPlainNumbers(engine.get(indexName, docId)),
+    listDocuments(indexName, params) {
+      return withPlainNumbers(engine.listDocuments(indexName, params));
+    },
+    listIndexes: async () => engine.listIndexes(),
+    getStats: async (indexName) => engine.getStats(indexName)
+  };
+}
+
 // src/react/constants.ts
 var DEFAULT_KEEP_ALIVE_MS = 2e3;
+var DEFAULT_REFRESH_AFTER_WRITE_MS = 200;
 var DEFAULT_TASK_POLL_INTERVAL_MS = 250;
 var ERROR_RETRY_INTERVAL_MS = 5e3;
 var MAX_QUERY_KEY_DEPTH = 32;
@@ -173,10 +219,13 @@ var IDLE_SNAPSHOT = Object.freeze({
   isLoading: false,
   isFetching: false
 });
-function createResourceStore(keepAliveMs = DEFAULT_KEEP_ALIVE_MS) {
+var ANY_INDEX = /* @__PURE__ */ Symbol("any index");
+var NO_INDEX = /* @__PURE__ */ Symbol("no index");
+function createResourceStore(keepAliveMs = DEFAULT_KEEP_ALIVE_MS, refreshAfterWriteMs = DEFAULT_REFRESH_AFTER_WRITE_MS) {
   const entries = /* @__PURE__ */ new Map();
   let holders = 0;
   let closing = null;
+  const staleRefreshes = /* @__PURE__ */ new Map();
   function publish(entry, next) {
     entry.snapshot = next;
     for (const listener of entry.listeners) listener();
@@ -185,6 +234,7 @@ function createResourceStore(keepAliveMs = DEFAULT_KEEP_ALIVE_MS) {
     if (entry.controller !== null) return;
     const controller = new AbortController();
     entry.controller = controller;
+    entry.stale = false;
     entry.version++;
     const version = entry.version;
     if (!entry.snapshot.isFetching) publish(entry, { ...entry.snapshot, isFetching: true });
@@ -209,9 +259,32 @@ function createResourceStore(keepAliveMs = DEFAULT_KEEP_ALIVE_MS) {
     );
   }
   function disposeAll() {
+    for (const timer of staleRefreshes.values()) clearTimeout(timer);
+    staleRefreshes.clear();
     for (const [key, entry] of [...entries]) drop(key, entry);
     entries.clear();
   }
+  function refreshStale(scope) {
+    staleRefreshes.delete(scope);
+    for (const [key, entry] of entries) {
+      if (entry.writeScope === scope && entry.stale && entry.listeners.size > 0) load(key, entry);
+    }
+  }
+  function scheduleRefresh(scope) {
+    const pending = staleRefreshes.get(scope);
+    if (pending !== void 0) clearTimeout(pending);
+    staleRefreshes.set(
+      scope,
+      setTimeout(() => refreshStale(scope), refreshAfterWriteMs)
+    );
+  }
+  function markStale(entry) {
+    entry.stale = true;
+    if (entry.controller === null) return;
+    entry.controller.abort();
+    entry.controller = null;
+    entry.version++;
+  }
   function drop(key, entry) {
     if (entries.get(key) === entry) entries.delete(key);
     if (entry.disposal !== null) clearTimeout(entry.disposal);
@@ -220,7 +293,7 @@ function createResourceStore(keepAliveMs = DEFAULT_KEEP_ALIVE_MS) {
     entry.controller = null;
   }
   return {
-    subscribe(key, loader, onChange) {
+    subscribe(key, loader, onChange, writeScope) {
       let entry = entries.get(key);
       if (entry === void 0) {
         entry = {
@@ -229,7 +302,9 @@ function createResourceStore(keepAliveMs = DEFAULT_KEEP_ALIVE_MS) {
           loader,
           controller: null,
           version: 0,
-          disposal: null
+          disposal: null,
+          writeScope,
+          stale: false
         };
         entries.set(key, entry);
       } else {
@@ -241,7 +316,7 @@ function createResourceStore(keepAliveMs = DEFAULT_KEEP_ALIVE_MS) {
       }
       const held = entry;
       held.listeners.add(onChange);
-      const retryable = held.snapshot.isLoading || held.snapshot.error !== void 0;
+      const retryable = held.stale || held.snapshot.isLoading || held.snapshot.error !== void 0;
       if (retryable && held.controller === null) load(key, held);
       return () => {
         held.listeners.delete(onChange);
@@ -259,6 +334,15 @@ function createResourceStore(keepAliveMs = DEFAULT_KEEP_ALIVE_MS) {
       const entry = entries.get(key);
       if (entry !== void 0) load(key, entry);
     },
+    invalidate(indexName) {
+      const marked = /* @__PURE__ */ new Set();
+      for (const entry of entries.values()) {
+        if (entry.writeScope !== ANY_INDEX && entry.writeScope !== indexName) continue;
+        markStale(entry);
+        marked.add(entry.writeScope);
+      }
+      for (const scope of marked) scheduleRefresh(scope);
+    },
     retain() {
       holders++;
       if (closing !== null) {
@@ -283,30 +367,72 @@ function createResourceStore(keepAliveMs = DEFAULT_KEEP_ALIVE_MS) {
 
 // src/react/context.ts
 var NarsilContext = createContext(null);
-function build(client, keepAliveMs) {
-  return { client, store: createResourceStore(keepAliveMs), keepAliveMs };
+function buildContextValue(props) {
+  const { client, engine, keepAliveMs, refreshAfterWriteMs } = props;
+  const shared = { store: createResourceStore(keepAliveMs, refreshAfterWriteMs), keepAliveMs, refreshAfterWriteMs };
+  if (client !== void 0 && engine === void 0) return { ...shared, reader: client, client, engine: null };
+  if (engine !== void 0 && client === void 0) {
+    return { ...shared, reader: engineReader(engine), client: null, engine };
+  }
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    "A NarsilProvider requires exactly one of client and engine, but its props set both or neither"
+  );
+}
+function providerPropsChanged(value, props) {
+  return value.client !== (props.client ?? null) || value.engine !== (props.engine ?? null) || value.keepAliveMs !== props.keepAliveMs || value.refreshAfterWriteMs !== props.refreshAfterWriteMs;
+}
+function useStoreRetention(store) {
+  useEffect(() => store.retain(), [store]);
+}
+function useRefreshAfterWrites(engine, store) {
+  useEffect(() => {
+    if (engine === null) return;
+    const onWrite = (payload) => {
+      store.invalidate(payload.indexName);
+    };
+    engine.on("write", onWrite);
+    return () => {
+      engine.off("write", onWrite);
+    };
+  }, [engine, store]);
 }
 function NarsilProvider(props) {
-  const { client, keepAliveMs, children } = props;
-  const [value, setValue] = useState(() => build(client, keepAliveMs));
-  if (value.client !== client || value.keepAliveMs !== keepAliveMs) {
-    setValue(build(client, keepAliveMs));
+  const [value, setValue] = useState(() => buildContextValue(props));
+  if (providerPropsChanged(value, props)) {
+    setValue(buildContextValue(props));
   }
-  useEffect(() => value.store.retain(), [value]);
-  return createElement(NarsilContext.Provider, { value }, children);
+  useStoreRetention(value.store);
+  useRefreshAfterWrites(value.engine, value.store);
+  return createElement(NarsilContext.Provider, { value }, props.children);
 }
 function useNarsilContext() {
   const value = useContext(NarsilContext);
   if (value === null) {
     throw new NarsilError(
       ErrorCodes.CONFIG_INVALID,
-      "A Narsil hook ran outside a NarsilProvider, so it found no client to send through"
+      "A Narsil hook was called outside a NarsilProvider, so no client or engine is available to it"
     );
   }
   return value;
 }
+function useServerClient(hookName) {
+  const { client } = useNarsilContext();
+  if (client !== null) return client;
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `${hookName} works only under a client of a server, because only a server handles tasks and imports, while the NarsilProvider above it holds an engine`,
+    { hook: hookName }
+  );
+}
 function useNarsilClient() {
-  return useNarsilContext().client;
+  const { client } = useNarsilContext();
+  if (client !== null) return client;
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    "useNarsilClient returns a client, while the NarsilProvider above it holds an engine, so import that engine directly",
+    { hook: "useNarsilClient" }
+  );
 }
 
 // src/react/key.ts
@@ -457,8 +583,8 @@ function useKey(parts) {
   cached.current = { parts, key };
   return key;
 }
-function useRead(parts, run, options) {
-  const { client, store } = useNarsilContext();
+function useRead(source, parts, run, options, writeScope) {
+  const { store } = useNarsilContext();
   const enabled = options?.enabled ?? true;
   const headers = options?.headers;
   const timeoutMs = options?.timeoutMs;
@@ -472,11 +598,11 @@ function useRead(parts, run, options) {
       if (!enabled) return NO_SUBSCRIPTION;
       const loader = (signal) => {
         const held = call.current;
-        return held.run(client, { ...held.request, signal });
+        return held.run(source, { ...held.request, signal });
       };
-      return store.subscribe(key, loader, onChange);
+      return store.subscribe(key, loader, onChange, writeScope);
     },
-    [enabled, store, client, key]
+    [enabled, store, source, key, writeScope]
   );
   const readSnapshot = useCallback(
     () => enabled ? store.snapshot(key) : IDLE_SNAPSHOT,
@@ -508,21 +634,28 @@ function useRead(parts, run, options) {
     [data, snapshot, refresh]
   );
 }
+function useProviderRead(parts, run, options, writeScope) {
+  const { reader } = useNarsilContext();
+  return useRead(reader, parts, run, options, writeScope);
+}
 
 // src/react/documents.ts
 function useDocument(indexName, docId, options) {
   const id = docId ?? "";
   const enabled = (options?.enabled ?? true) && id.length > 0;
-  return useRead(["get", indexName, id], (client, request) => client.get(indexName, id, request), {
-    ...options,
-    enabled
-  });
+  return useProviderRead(
+    ["get", indexName, id],
+    (reader, request) => reader.get(indexName, id, request),
+    { ...options, enabled },
+    indexName
+  );
 }
 function useDocuments(indexName, params, options) {
-  return useRead(
+  return useProviderRead(
     ["listDocuments", indexName, params],
-    (client, request) => client.listDocuments(indexName, params, request),
-    options
+    (reader, request) => reader.listDocuments(indexName, params, request),
+    options,
+    indexName
   );
 }
 
@@ -544,7 +677,7 @@ function isTerminalTask(record) {
 // src/react/import.ts
 var NOTHING = { task: void 0, error: void 0, starting: false };
 function useImport(indexName, options) {
-  const client = useNarsilClient();
+  const client = useServerClient("useImport");
   const [progress, setProgress] = useState(NOTHING);
   const polling = useRef(null);
   const sending = useRef(null);
@@ -652,51 +785,63 @@ function useImport(indexName, options) {
 
 // src/react/indexes.ts
 function useIndexes(options) {
-  return useRead(["listIndexes"], (client, request) => client.listIndexes(request), options);
+  return useProviderRead(["listIndexes"], (reader, request) => reader.listIndexes(request), options, ANY_INDEX);
 }
 function useStats(indexName, options) {
-  return useRead(["getStats", indexName], (client, request) => client.getStats(indexName, request), options);
+  return useProviderRead(
+    ["getStats", indexName],
+    (reader, request) => reader.getStats(indexName, request),
+    options,
+    indexName
+  );
 }
 
 // src/react/search.ts
 function useQuery(indexName, params, options) {
-  return useRead(
+  return useProviderRead(
     ["query", indexName, params],
-    (client, request) => client.query(indexName, params, request),
-    options
+    (reader, request) => reader.query(indexName, params, request),
+    options,
+    indexName
   );
 }
 function usePreflight(indexName, params, options) {
-  return useRead(
+  return useProviderRead(
     ["preflight", indexName, params],
-    (client, request) => client.preflight(indexName, params, request),
-    options
+    (reader, request) => reader.preflight(indexName, params, request),
+    options,
+    indexName
   );
 }
 function useSuggest(indexName, params, options) {
-  return useRead(
+  return useProviderRead(
     ["suggest", indexName, params],
-    (client, request) => client.suggest(indexName, params, request),
-    options
+    (reader, request) => reader.suggest(indexName, params, request),
+    options,
+    indexName
   );
 }
 
 // src/react/tasks.ts
 function useTask(taskId, options) {
+  const client = useServerClient("useTask");
   const id = taskId ?? "";
   const enabled = (options?.enabled ?? true) && id.length > 0;
-  const state = useRead(["getTask", id], (client, request) => client.getTask(id, request), {
-    ...options,
-    enabled,
-    refreshIntervalMs: 0
-  });
+  const state = useRead(
+    client,
+    ["getTask", id],
+    (server, request) => server.getTask(id, request),
+    { ...options, enabled, refreshIntervalMs: 0 },
+    NO_INDEX
+  );
   const running = state.data !== null && !isTerminalTask(state.data);
   const interval = pollInterval(options?.pollIntervalMs ?? DEFAULT_TASK_POLL_INTERVAL_MS, state.error !== void 0);
   usePolling(state.refresh, interval, enabled && running);
   return state;
 }
 function useTasks(query, options) {
-  return useRead(["listTasks", query], (client, request) => client.listTasks(query, request), options);
+  const client = useServerClient("useTasks");
+  return useRead(client, ["listTasks", query], (server, request) => server.listTasks(query, request), options, NO_INDEX);
 }
 
 export { ClientErrorCodes, ErrorCodes, NarsilError, NarsilProvider, ServerErrorCodes, isNarsilError, useDocument, useDocuments, useImport, useIndexes, useNarsilClient, usePreflight, useQuery, useStats, useSuggest, useTask, useTasks };

package/dist/{schema-Bgzr4g7b.d.ts → schema-BBOCdhND.d.ts}

@@ -18,12 +18,13 @@ type AnyDocument = Record<string, unknown> & {
  *
  * The engine can sort by a field whose type includes `sortable`. On a single
  * `string` field with that option, the engine can also test a text range with
- * `gt`, `gte`, `lt`, `lte`, or `between`. The engine raises
- * `DOC_VALIDATION_FAILED` for a value longer than
- * {@link IndexConfig.patternValueLimit} in a field whose type includes
- * `pattern`. A later release will add pattern search and partial-word search,
- * which will test the fields whose types include `pattern` and `partial`
- * respectively.
+ * `gt`, `gte`, `lt`, `lte`, or `between`. The engine keeps a pattern index for
+ * a field whose type includes `pattern`. It answers `contains`, `eq`, `ne`,
+ * `in`, `nin`, `startsWith`, and `endsWith` on that field from the index,
+ * comparing case folds for any of those tests that sets `caseFold`. The engine
+ * raises `DOC_VALIDATION_FAILED` for a value longer than
+ * {@link IndexConfig.patternValueLimit} in such a field. A later release will
+ * add partial-word search for the fields whose types include `partial`.
  *
  * @public
  */
@@ -51,7 +52,8 @@ type FieldOptionChain<Remaining extends string> = {
  * The engine stores and compares a `verbatim` value exactly as written, as one
  * piece of text. Because the engine keeps that value whole, it leaves the
  * field out of keyword search, although it can test the whole value in a
- * filter.
+ * filter. The engine keeps a pattern index for every `verbatim` field, so it
+ * can also test such a field with `contains` and `caseFold`.
  *
  * Add the {@link TextFieldOption} options to a `string` or `string[]` type, or
  * `sortable` alone to a `verbatim` or `verbatim[]` type, as in

package/dist/server.d.ts

@@ -1,14 +1,14 @@
-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-C7UMCMH3.js';
-import { b as ServerOptions, N as NarsilServer } from './capabilities-Dt-7B4Wz.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-Dt-7B4Wz.js';
-import { a as Narsil } from './engine-CXKfmK7I.js';
-import { d as TaskProgress, b as ImportResult, h as TaskStore, e as TaskRecord } from './tasks-BZt_zes6.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-BZt_zes6.js';
-import './schema-Bgzr4g7b.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-CKHTU1CL.js';
+import { b as ServerOptions, N as NarsilServer } from './capabilities-D6gjjQyA.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-D6gjjQyA.js';
+import { a as Narsil } from './engine-Dm4446j1.js';
+import { d as TaskProgress, b as ImportResult, h as TaskStore, e as TaskRecord } from './tasks-BECd0b__.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-BECd0b__.js';
+import './schema-BBOCdhND.js';
 import './adapters-79OIa4xm.js';
-import './config-rBpbgTw8.js';
-import './config-Dfanyqqt.js';
-import './types-gOUqhs2F.js';
+import './config-BLguB-om.js';
+import './config-C7Ip8Ife.js';
+import './types-BiUmaiWT.js';
 import './types-D5OwhtsQ.js';
 
 /**

package/dist/server.mjs

@@ -1,17 +1,17 @@
-import { DEFAULT_MAX_RETAINED_TASKS, loadUWebSockets, resolveCors, authorizerFor, createSharedGateBuffer, gateSlotOfWorker, createRouteRunner, corsHeaderReader, 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-2STVUTNA.mjs';
-export { ASYNC_IMPORT_CAPABILITY, INDEX_LIFECYCLE_CAPABILITY, REBUILD_ANALYSIS_CAPABILITY, SERVER_CAPABILITIES, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, httpStatusForNarsilError } from './chunk-2STVUTNA.mjs';
-import { validateIndexName } from './chunk-3JGWULDF.mjs';
-import { engineCoreOf, providedDocId, resolveVectorText } from './chunk-FVLQ63B7.mjs';
-import { detectRuntime } from './chunk-HWQLTLNG.mjs';
-import './chunk-GIVAGD3Q.mjs';
-import './chunk-653BNMAF.mjs';
+import { DEFAULT_MAX_RETAINED_TASKS, loadUWebSockets, resolveCors, authorizerFor, createSharedGateBuffer, gateSlotOfWorker, createRouteRunner, corsHeaderReader, 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-EDMCZLSJ.mjs';
+export { ASYNC_IMPORT_CAPABILITY, INDEX_LIFECYCLE_CAPABILITY, REBUILD_ANALYSIS_CAPABILITY, SERVER_CAPABILITIES, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, httpStatusForNarsilError } from './chunk-EDMCZLSJ.mjs';
+import { validateIndexName } from './chunk-Y52WZWAU.mjs';
+import { engineCoreOf, providedDocId, resolveVectorText } from './chunk-CVPA5Q7R.mjs';
+import './chunk-XZ4PAREY.mjs';
+import { detectRuntime } from './chunk-KZTI25D3.mjs';
+import './chunk-M6XF5HDE.mjs';
 import './chunk-TGP5M5R7.mjs';
-import './chunk-YNVIUGF5.mjs';
+import './chunk-P2ZZN32C.mjs';
 import './chunk-U2BKYEC7.mjs';
-import './chunk-OI42GWLR.mjs';
+import './chunk-LJYTW7GT.mjs';
 import { startIdleHeapCleanup } from './chunk-Y3L5MDRV.mjs';
-import { NarsilError, ErrorCodes, ServerErrorCodes, isNarsilError } from './chunk-USKFU7J5.mjs';
-export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, isNarsilError } from './chunk-USKFU7J5.mjs';
+import { NarsilError, ErrorCodes, ServerErrorCodes, isNarsilError } from './chunk-RV77FR2F.mjs';
+export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, isNarsilError } from './chunk-RV77FR2F.mjs';
 import { randomUUID } from 'crypto';
 import { MessageChannel } from 'worker_threads';
 
@@ -982,7 +982,8 @@ async function startRequestThreads(options) {
               limits: options.limits,
               build: options.build,
               authorizes: authorize !== void 0,
-              searchHooks
+              searchHooks,
+              patternWorkCap: options.core.patternWorkCap
             }
           },
           [channel.port1]

package/dist/{tasks-BZt_zes6.d.ts → tasks-BECd0b__.d.ts}

@@ -1,4 +1,4 @@
-import { M as MemoryStats } from './memory-C7UMCMH3.js';
+import { M as MemoryStats } from './memory-CKHTU1CL.js';
 
 /** Declarative index configuration accepted over HTTP. Function-valued engine
  * options (custom tokenizer, stopWords-as-function, group reducer, embedding

package/dist/{thread-JEVAYETR.mjs → thread-IBSIZZ6W.mjs}

@@ -1,12 +1,13 @@
-import { loadUWebSockets, childAppOf, createRouteRunner, corsHeaderReader, createSharedRequestGate, registerServerRoutes, sendRelayed, createDocumentReadHandlers, respondJson, SERVER_CAPABILITIES, versionReport, sendError, serverRoutes, parseJson, validateSuggest, rejectInvalid, respondError, validateQuery } from './chunk-2STVUTNA.mjs';
-import { executeListDocuments, executeSuggest, executePreflight, queryBindingOf, executeQuery } from './chunk-P4DSQ6M4.mjs';
-import './chunk-GIVAGD3Q.mjs';
-import { resolveProjection, projectionKeepsField, setNestedValue } from './chunk-LMO5TJUS.mjs';
-import { extractVectorFieldsFromSchema } from './chunk-653BNMAF.mjs';
+import { loadUWebSockets, childAppOf, createRouteRunner, corsHeaderReader, createSharedRequestGate, registerServerRoutes, sendRelayed, createDocumentReadHandlers, respondJson, SERVER_CAPABILITIES, versionReport, sendError, serverRoutes, parseJson, validateSuggest, rejectInvalid, respondError, validateQuery } from './chunk-EDMCZLSJ.mjs';
+import { executeListDocuments, executeSuggest, executePreflight, queryBindingOf, executeQuery } from './chunk-2X2ZQOAB.mjs';
+import './chunk-XZ4PAREY.mjs';
+import { resolveProjection, projectionKeepsField, setNestedValue } from './chunk-QR4OKRVY.mjs';
+import { extractVectorFieldsFromSchema } from './chunk-M6XF5HDE.mjs';
 import './chunk-ZJ4CSAB2.mjs';
-import './chunk-YNVIUGF5.mjs';
-import './chunk-OI42GWLR.mjs';
-import { ServerErrorCodes, NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
+import './chunk-P2ZZN32C.mjs';
+import './chunk-ZKRV5M2P.mjs';
+import './chunk-LJYTW7GT.mjs';
+import { ServerErrorCodes, NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
 
 // src/server/request-threads/held-vectors.ts
 function managerWithHeldVectors(manager, fieldPaths, vectorOf) {
@@ -28,7 +29,7 @@ function managerWithHeldVectors(manager, fieldPaths, vectorOf) {
 
 // src/server/request-threads/read-engine.ts
 function createThreadReadEngine(options) {
-  const { executor, relay, searchHooks } = options;
+  const { executor, relay, searchHooks, patternWorkCap } = options;
   function vectorFieldsOf(context) {
     return [...extractVectorFieldsFromSchema(context.config.schema).keys()];
   }
@@ -110,7 +111,8 @@ function createThreadReadEngine(options) {
         config: context.config,
         indexName,
         cursorBinding: queryBindingOf(params),
-        vectorSearchers: context.vectorSearchers
+        vectorSearchers: context.vectorSearchers,
+        patternWorkCap
       });
       if (context.analysisStale) result.analysisStale = true;
       return result;
@@ -123,7 +125,8 @@ function createThreadReadEngine(options) {
         config: context.config,
         indexName,
         cursorBinding: queryBindingOf(params),
-        vectorSearchers: context.vectorSearchers
+        vectorSearchers: context.vectorSearchers,
+        patternWorkCap
       });
       if (context.analysisStale) result.analysisStale = true;
       return result;
@@ -157,7 +160,8 @@ function createThreadReadEngine(options) {
       return executeListDocuments(params ?? {}, {
         manager,
         schema: context.config.schema,
-        strict: context.config.strict
+        strict: context.config.strict,
+        patternWorkCap
       });
     }
   };
@@ -381,7 +385,12 @@ async function serveRequests(executor, settings) {
   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 local = createThreadReadEngine({
+    executor,
+    relay,
+    searchHooks: settings.searchHooks,
+    patternWorkCap: settings.patternWorkCap
+  });
   const run = createRouteRunner({
     authorize: settings.authorizes ? (context) => relay.authorize(context) : void 0,
     gate: createSharedRequestGate(settings.gate, settings.maxConcurrentRequests, settings.gateSlot),

package/dist/{types-gOUqhs2F.d.ts → types-BiUmaiWT.d.ts}

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

package/dist/vector/search-worker.d.ts

@@ -1,4 +1,4 @@
-import { e as VectorQuantizationMode } from '../schema-Bgzr4g7b.js';
+import { e as VectorQuantizationMode } from '../schema-BBOCdhND.js';
 import { A as ArenaSimd } from '../simd-DW5AtJ6B.js';
 import '../adapters-79OIa4xm.js';
 

package/dist/vector/search-worker.mjs

@@ -1,8 +1,8 @@
-import { openSharedVectorField, MAX_WORKER_COPIES, createVectorStore, osqBitsOf, createHNSWIndex, createOsqQuantizer, osqRecordBytes } from '../chunk-YJDQ7NLA.mjs';
+import { openSharedVectorField, MAX_WORKER_COPIES, createVectorStore, osqBitsOf, createHNSWIndex, createOsqQuantizer, osqRecordBytes } from '../chunk-LCCL6EEH.mjs';
 import '../chunk-ZJ4CSAB2.mjs';
-import '../chunk-YNVIUGF5.mjs';
-import '../chunk-OI42GWLR.mjs';
-import '../chunk-USKFU7J5.mjs';
+import '../chunk-P2ZZN32C.mjs';
+import '../chunk-LJYTW7GT.mjs';
+import '../chunk-RV77FR2F.mjs';
 
 // src/vector/worker-copy.ts
 function restoreQuantizer(snapshot, store) {

package/dist/workers/entry.mjs

@@ -1,6 +1,6 @@
 import { startIdleHeapCleanup } from '../chunk-Y3L5MDRV.mjs';
 import { threadSlotOfWorker, isValidWorkerAction } from '../chunk-POWOTUKJ.mjs';
-import { ErrorCodes, NarsilError, isNarsilError } from '../chunk-USKFU7J5.mjs';
+import { ErrorCodes, NarsilError, isNarsilError } from '../chunk-RV77FR2F.mjs';
 
 // src/workers/action-handler.ts
 function buildErrorResponse(requestId, code, message, details) {
@@ -18,7 +18,7 @@ async function importBootstrapModule(moduleUrl) {
   await import(moduleUrl);
 }
 async function stopServingRequests() {
-  const { closeRequestThread } = await import('../thread-JEVAYETR.mjs');
+  const { closeRequestThread } = await import('../thread-IBSIZZ6W.mjs');
   closeRequestThread();
 }
 function holdsCopies(executor) {
@@ -49,7 +49,7 @@ function createActionHandler(executor) {
         if (!holdsCopies(executor)) {
           throw new NarsilError(ErrorCodes.CONFIG_INVALID, "This executor holds no copies to answer requests from");
         }
-        const starting = import('../thread-JEVAYETR.mjs').then(
+        const starting = import('../thread-IBSIZZ6W.mjs').then(
           ({ serveRequests }) => serveRequests(executor, action.settings)
         );
         serving.start = starting.then(
@@ -102,7 +102,7 @@ async function setup() {
   } catch {
     parentPort = null;
   }
-  const { createDirectExecutor } = await import('../direct-executor-GYJEKNV5.mjs');
+  const { createDirectExecutor } = await import('../direct-executor-SVCHXR74.mjs');
   const handleAction = createActionHandler(createDirectExecutor({ threadSlot }));
   if (parentPort) {
     const port = parentPort;