@delali/narsil 0.3.1-next.69 → 0.3.1-next.71

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");
@@ -147,8 +147,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 +218,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 +233,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 +258,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 +292,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 +301,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 +315,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 +333,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 +366,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 +582,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 +597,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 +633,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 +676,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 +784,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-d5Afu03A.d.ts → schema-Bgzr4g7b.d.ts}

@@ -13,20 +13,63 @@ type AnyDocument = Record<string, unknown> & {
     id?: string;
 };
 /**
- * The type a schema field declares, which sets how the engine indexes it.
+ * Each of these options can follow the base type of a `string` or `string[]`
+ * field after a colon, as in `string:sortable:pattern`.
  *
- * `string` is analysed and searchable, `number`, `boolean`, and `enum` are
- * filterable and sortable, `geopoint` accepts a latitude and longitude pair,
- * and `vector[N]` holds an N-dimensional embedding. Each array form indexes
- * every element of the field.
+ * 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.
  *
- * `string:sortable` is a `string` in every respect, and a sort may name it.
- * Ordering text costs far more memory per document than ordering a number, so
- * a sort naming a plain `string` field raises `SEARCH_INVALID_FIELD`.
+ * @public
+ */
+type TextFieldOption = 'sortable' | 'pattern' | 'partial';
+/**
+ * This union contains every string of options that can follow a base type,
+ * with each option after a colon. The options can come in any order, although
+ * each one can appear only once.
  *
  * @public
  */
-type FieldType = 'string' | 'string:sortable' | 'number' | 'boolean' | 'enum' | 'geopoint' | `vector[${number}]` | 'string[]' | 'number[]' | 'boolean[]' | 'enum[]';
+type FieldOptionChain<Remaining extends string> = {
+    [Option in Remaining]: `:${Option}` | `:${Option}${FieldOptionChain<Exclude<Remaining, Option>>}`;
+}[Remaining];
+/**
+ * The engine indexes each field of a schema according to the field's type,
+ * which is one of these.
+ *
+ * The engine splits a `string` value into words, so it can find the document
+ * by any word in the value. It can filter and sort by a `number`, `boolean`,
+ * or `enum` field. A `geopoint` value is a latitude and longitude pair. A
+ * `vector[N]` value is an embedding with N dimensions. For each list form, the
+ * engine indexes every element of the list.
+ *
+ * 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.
+ *
+ * Add the {@link TextFieldOption} options to a `string` or `string[]` type, or
+ * `sortable` alone to a `verbatim` or `verbatim[]` type, as in
+ * `string:sortable:pattern` or `verbatim[]:sortable`. The engine stores the
+ * options in the order `sortable`, `pattern`, `partial`, whatever their order
+ * in the type name. It raises `SCHEMA_INVALID_TYPE` for any other
+ * option, such as `number:sortable` or `verbatim:pattern`, and for an option
+ * written twice.
+ *
+ * To sort by a text field, the engine keeps up to the first 512 code points of
+ * every document's value in memory, against 8 bytes per document for a number
+ * field. For that reason, the engine sorts by a text field only where the
+ * field's type includes `sortable`, while it raises `SEARCH_INVALID_FIELD`
+ * for a sort on any other text field.
+ *
+ * @public
+ */
+type FieldType = 'string' | `string${FieldOptionChain<TextFieldOption>}` | 'string[]' | `string[]${FieldOptionChain<TextFieldOption>}` | 'verbatim' | 'verbatim:sortable' | 'verbatim[]' | 'verbatim[]:sortable' | 'number' | 'boolean' | 'enum' | 'geopoint' | `vector[${number}]` | 'number[]' | 'boolean[]' | 'enum[]';
 /**
  * The field layout of an index, written as a plain object.
  *
@@ -173,6 +216,15 @@ interface IndexConfig {
      * insert throughput and one entry per changed spelling.
      */
     surfaceForms?: boolean;
+    /**
+     * The engine raises `DOC_VALIDATION_FAILED` for a document whose value in a
+     * `verbatim` field, or in a field whose type includes `pattern`, is longer
+     * than this many code points. It tests each element of a list on its own.
+     * Set a whole number from 1 to 65,536, or leave this unset for a limit of
+     * 8,192. For any other value, {@link Narsil.createIndex} throws
+     * `CONFIG_INVALID`.
+     */
+    patternValueLimit?: number;
 }
 /**
  * BM25 tuning for an index.
@@ -286,4 +338,4 @@ interface InsertOptions extends WriteOptions {
     skipClone?: boolean;
 }
 
-export type { AnyDocument as A, BM25Params as B, CustomTokenizer as C, EmbeddingFieldConfig as E, FieldType as F, IndexConfig as I, PartitionConfig as P, SchemaDefinition as S, VectorIndexConfig as V, WriteOptions as W, InsertOptions as a, StopWordOverride as b, ScoringMode as c, VectorQuantizationMode as d, VectorStorageMode as e };
+export type { AnyDocument as A, BM25Params as B, CustomTokenizer as C, EmbeddingFieldConfig as E, FieldOptionChain as F, IndexConfig as I, PartitionConfig as P, SchemaDefinition as S, TextFieldOption as T, VectorIndexConfig as V, WriteOptions as W, InsertOptions as a, StopWordOverride as b, FieldType as c, ScoringMode as d, VectorQuantizationMode as e, VectorStorageMode as f };

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-CKF-9WLP.js';
-import { b as ServerOptions, N as NarsilServer } from './capabilities-B1wz2Zl0.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-B1wz2Zl0.js';
-import { a as Narsil } from './engine-77ErLy8P.js';
-import { d as TaskProgress, b as ImportResult, h as TaskStore, e as TaskRecord } from './tasks-BEiNxDRs.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-BEiNxDRs.js';
-import './schema-d5Afu03A.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-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-igk0aMpQ.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';
 import './adapters-79OIa4xm.js';
-import './config-CSvCVtB7.js';
-import './config-CEeSV_Xo.js';
-import './types-DAK7mnUZ.js';
+import './config-rBpbgTw8.js';
+import './config-Dfanyqqt.js';
+import './types-gOUqhs2F.js';
 import './types-D5OwhtsQ.js';
 
 /**

package/dist/server.mjs

@@ -1,11 +1,14 @@
-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-DD5X23E6.mjs';
-export { ASYNC_IMPORT_CAPABILITY, INDEX_LIFECYCLE_CAPABILITY, REBUILD_ANALYSIS_CAPABILITY, SERVER_CAPABILITIES, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, httpStatusForNarsilError } from './chunk-DD5X23E6.mjs';
-import { validateIndexName } from './chunk-VTPLKNWI.mjs';
-import { engineCoreOf, providedDocId, resolveVectorText } from './chunk-YA52AC2V.mjs';
-import { detectRuntime } from './chunk-AV4IJKD2.mjs';
-import './chunk-5JLSTECC.mjs';
-import './chunk-6TGZG2TV.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-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 './chunk-TGP5M5R7.mjs';
 import './chunk-YNVIUGF5.mjs';
+import './chunk-U2BKYEC7.mjs';
+import './chunk-OI42GWLR.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';
@@ -594,6 +597,7 @@ function mapHttpIndexConfig(http) {
   if (http.vectorPromotion !== void 0) config.vectorPromotion = http.vectorPromotion;
   if (http.strict !== void 0) config.strict = http.strict;
   if (http.required !== void 0) config.required = http.required;
+  if (http.patternValueLimit !== void 0) config.patternValueLimit = http.patternValueLimit;
   if (http.stopWords !== void 0) {
     if (!Array.isArray(http.stopWords) || http.stopWords.some((w) => typeof w !== "string")) {
       throw new NarsilError(ErrorCodes.CONFIG_INVALID, 'Field "stopWords" must be an array of strings');

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

@@ -1,4 +1,4 @@
-import { M as MemoryStats } from './memory-CKF-9WLP.js';
+import { M as MemoryStats } from './memory-C7UMCMH3.js';
 
 /** Declarative index configuration accepted over HTTP. Function-valued engine
  * options (custom tokenizer, stopWords-as-function, group reducer, embedding
@@ -68,6 +68,8 @@ interface HttpIndexConfig {
     embedding?: CreateIndexEmbedding;
     /** The server rejects a document that omits any of these fields. */
     required?: string[];
+    /** The server returns a `DOC_VALIDATION_FAILED` error for a document whose value in a `verbatim` field, or in a field whose type includes `pattern`, is longer than this many code points. Set a whole number from 1 to 65,536, or leave this unset for a limit of 8,192. */
+    patternValueLimit?: number;
 }
 /**
  * One record an import refused, naming the line it came from and why the

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

@@ -1,11 +1,11 @@
-import { loadUWebSockets, childAppOf, createRouteRunner, corsHeaderReader, createSharedRequestGate, registerServerRoutes, sendRelayed, createDocumentReadHandlers, respondJson, SERVER_CAPABILITIES, versionReport, sendError, serverRoutes, parseJson, validateSuggest, rejectInvalid, respondError, validateQuery } from './chunk-DD5X23E6.mjs';
-import { executeListDocuments, executeSuggest, executePreflight, queryBindingOf, executeQuery } from './chunk-2BDG2IWP.mjs';
-import './chunk-5JLSTECC.mjs';
-import { resolveProjection, projectionKeepsField, setNestedValue } from './chunk-4VU5TWCR.mjs';
-import { extractVectorFieldsFromSchema } from './chunk-6TGZG2TV.mjs';
+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 './chunk-ZJ4CSAB2.mjs';
 import './chunk-YNVIUGF5.mjs';
-import './chunk-YMZCMH5M.mjs';
+import './chunk-OI42GWLR.mjs';
 import { ServerErrorCodes, NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
 
 // src/server/request-threads/held-vectors.ts

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

@@ -1,4 +1,4 @@
-import { S as SchemaDefinition } from './schema-d5Afu03A.js';
+import { S as SchemaDefinition } from './schema-Bgzr4g7b.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 { d as VectorQuantizationMode } from '../schema-d5Afu03A.js';
+import { e as VectorQuantizationMode } from '../schema-Bgzr4g7b.js';
 import { A as ArenaSimd } from '../simd-DW5AtJ6B.js';
 import '../adapters-79OIa4xm.js';
 

package/dist/vector/search-worker.mjs

@@ -1,7 +1,7 @@
-import { openSharedVectorField, MAX_WORKER_COPIES, createVectorStore, osqBitsOf, createHNSWIndex, createOsqQuantizer, osqRecordBytes } from '../chunk-THYRHHO2.mjs';
+import { openSharedVectorField, MAX_WORKER_COPIES, createVectorStore, osqBitsOf, createHNSWIndex, createOsqQuantizer, osqRecordBytes } from '../chunk-YJDQ7NLA.mjs';
 import '../chunk-ZJ4CSAB2.mjs';
 import '../chunk-YNVIUGF5.mjs';
-import '../chunk-YMZCMH5M.mjs';
+import '../chunk-OI42GWLR.mjs';
 import '../chunk-USKFU7J5.mjs';
 
 // src/vector/worker-copy.ts

package/dist/workers/entry.mjs

@@ -18,7 +18,7 @@ async function importBootstrapModule(moduleUrl) {
   await import(moduleUrl);
 }
 async function stopServingRequests() {
-  const { closeRequestThread } = await import('../thread-FLP45EUD.mjs');
+  const { closeRequestThread } = await import('../thread-JEVAYETR.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-FLP45EUD.mjs').then(
+        const starting = import('../thread-JEVAYETR.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-3ZYXSGFX.mjs');
+  const { createDirectExecutor } = await import('../direct-executor-GYJEKNV5.mjs');
   const handleAction = createActionHandler(createDirectExecutor({ threadSlot }));
   if (parentPort) {
     const port = parentPort;