@delali/narsil 0.2.4-next.55 → 0.3.0

package/dist/{chunk-L225SHNB.mjs → chunk-L6TNPLAR.mjs}

@@ -1,5 +1,5 @@
-import { MAX_M } from './chunk-UTOFOJOR.mjs';
-import { NarsilError, ErrorCodes } from './chunk-FRQVMFY7.mjs';
+import { MAX_M } from './chunk-YNVIUGF5.mjs';
+import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
 
 // src/schema/constants.ts
 var MAX_NESTING_DEPTH = 4;
@@ -23,6 +23,9 @@ function isTextFieldType(fieldType) {
   return fieldType === "string" || fieldType === SORTABLE_TEXT_FIELD_TYPE;
 }
 var VECTOR_PATTERN = /^vector\[(\d+)]$/;
+function isGeopointOrVectorType(fieldType) {
+  return fieldType === "geopoint" || fieldType !== void 0 && VECTOR_PATTERN.test(fieldType);
+}
 var FIELD_NAME_PATTERN = /^[A-Za-z0-9_]+$/;
 var RESERVED_ROOT_FIELDS = /* @__PURE__ */ new Set(["id"]);
 var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
@@ -115,9 +118,13 @@ function flattenRecursive(schema, prefix, result) {
     }
   }
 }
+var flattenedSchemas = /* @__PURE__ */ new WeakMap();
 function flattenSchema(schema) {
-  const result = {};
+  const cached = flattenedSchemas.get(schema);
+  if (cached !== void 0) return cached;
+  const result = /* @__PURE__ */ Object.create(null);
   flattenRecursive(schema, "", result);
+  flattenedSchemas.set(schema, Object.freeze(result));
   return result;
 }
 function extractVectorFieldsFromSchema(schema) {
@@ -407,7 +414,7 @@ function collectExtraFields(doc, schema, prefix, extras) {
   for (const key of Object.keys(doc)) {
     if (key === "id") continue;
     const path = prefix ? `${prefix}.${key}` : key;
-    if (!(key in schema)) {
+    if (!Object.hasOwn(schema, key)) {
       extras.push(path);
       continue;
     }
@@ -509,5 +516,12 @@ var MAX_SORT_FIELDS = 8;
 var MAX_SORT_FIELD_NAME_LENGTH = 255;
 var MAX_CURSOR_ANCHOR_CODE_POINTS = 512;
 var PREFIX_MAX_EXPANSIONS = 50;
+var DEFAULT_FUZZY_PREFIX_LENGTH = 2;
+var DEFAULT_MAX_PER_GROUP = 1;
+var DEFAULT_RANK_CONSTANT = 60;
+var MIN_RANK_CONSTANT = 1;
+var DEFAULT_LINEAR_ALPHA = 0.5;
+var MIN_LINEAR_ALPHA = 0;
+var MAX_LINEAR_ALPHA = 1;
 
-export { DEFAULT_PAGE_SIZE, MAX_CURSOR_ANCHOR_CODE_POINTS, MAX_CURSOR_LENGTH, MAX_NESTING_DEPTH, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, PREFIX_MAX_EXPANSIONS, PROTOTYPE_POLLUTION_KEYS, RESULT_WINDOW, SORTABLE_TEXT_FIELD_TYPE, VECTOR_PATTERN, extractVectorFieldsFromSchema, flattenSchema, isQuantizationMode, isStorageMode, isTextFieldType, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion, validateVectorStorage };
+export { DEFAULT_FUZZY_PREFIX_LENGTH, DEFAULT_LINEAR_ALPHA, DEFAULT_MAX_PER_GROUP, DEFAULT_PAGE_SIZE, DEFAULT_RANK_CONSTANT, MAX_CURSOR_ANCHOR_CODE_POINTS, MAX_CURSOR_LENGTH, MAX_LINEAR_ALPHA, MAX_NESTING_DEPTH, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MIN_LINEAR_ALPHA, MIN_RANK_CONSTANT, PREFIX_MAX_EXPANSIONS, PROTOTYPE_POLLUTION_KEYS, RESULT_WINDOW, SORTABLE_TEXT_FIELD_TYPE, VECTOR_PATTERN, extractVectorFieldsFromSchema, flattenSchema, isGeopointOrVectorType, isQuantizationMode, isStorageMode, isTextFieldType, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion, validateVectorStorage };

package/dist/{chunk-U2AL3SON.mjs → chunk-THYRHHO2.mjs}

@@ -1,7 +1,7 @@
 import { OSQ_STEPS, OSQ_GRID, OSQ_REFINE_ROUNDS, OSQ_REFINE_TOLERANCE, OSQ4_NARROW_DIMENSION_LIMIT, DEFAULT_OSQ4_NARROW_OVERSAMPLE, DEFAULT_OVERSAMPLE_BY_BITS, OSQ_QUERY_BITS, OSQ_LAMBDA } from './chunk-ZJ4CSAB2.mjs';
-import { COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, nativeSearchCoreIsEnabled, loadNativeCore, stopUsingTheNativeSearchCore, noteFallback, MAX_LAYER_CAP, PLACEMENT_ROOM_REQUESTS, INITIAL_LIST_CAPACITY, DEFAULT_EF_SEARCH, INITIAL_UPPER_SLOTS } from './chunk-UTOFOJOR.mjs';
-import { compareCodePoints } from './chunk-2GWVQWGA.mjs';
-import { NarsilError, ErrorCodes } from './chunk-FRQVMFY7.mjs';
+import { COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, nativeSearchCoreIsEnabled, loadNativeCore, stopUsingTheNativeSearchCore, noteFallback, MAX_LAYER_CAP, PLACEMENT_ROOM_REQUESTS, INITIAL_LIST_CAPACITY, DEFAULT_EF_SEARCH, INITIAL_UPPER_SLOTS } from './chunk-YNVIUGF5.mjs';
+import { compareCodePoints } from './chunk-YMZCMH5M.mjs';
+import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
 import { readSync, closeSync, openSync } from 'fs';
 
 // src/vector/constants.ts

package/dist/{chunk-NTZYA3SJ.mjs → chunk-U7KYW4BA.mjs}

@@ -1,6 +1,6 @@
-import { MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR } from './chunk-4NVPQ6S5.mjs';
-import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN } from './chunk-D2S642IV.mjs';
-import { NarsilError, ErrorCodes } from './chunk-FRQVMFY7.mjs';
+import { MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR } from './chunk-UXNWQZST.mjs';
+import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN } from './chunk-3LHGNRYE.mjs';
+import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 var INDEX_CONFIG_PREFIX = "_narsil/index/";

package/dist/{chunk-FRQVMFY7.mjs → chunk-USKFU7J5.mjs}

@@ -12,6 +12,7 @@ var ErrorCodes = {
   INDEX_ALREADY_EXISTS: "INDEX_ALREADY_EXISTS",
   INDEX_ORPHANED: "INDEX_ORPHANED",
   INDEX_REOPEN_CAPACITY_EXHAUSTED: "INDEX_REOPEN_CAPACITY_EXHAUSTED",
+  INSTANCE_SHUT_DOWN: "INSTANCE_SHUT_DOWN",
   PARTITION_CORRUPTED: "PARTITION_CORRUPTED",
   PARTITION_REBALANCING_BACKPRESSURE: "PARTITION_REBALANCING_BACKPRESSURE",
   WORKER_CRASHED: "WORKER_CRASHED",

package/dist/{chunk-4NVPQ6S5.mjs → chunk-UXNWQZST.mjs}

@@ -1,5 +1,5 @@
-import { validateRequiredFields } from './chunk-L225SHNB.mjs';
-import { ErrorCodes, NarsilError } from './chunk-FRQVMFY7.mjs';
+import { validateRequiredFields } from './chunk-L6TNPLAR.mjs';
+import { ErrorCodes, NarsilError } from './chunk-USKFU7J5.mjs';
 
 // src/narsil/internals.ts
 var engineCores = /* @__PURE__ */ new WeakMap();
@@ -344,7 +344,16 @@ async function resolveVectorText(params, embeddingAdapter, signal, embeddingAdap
   if (params.vector.text.length === 0) {
     throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Vector query 'text' must not be empty");
   }
-  const raw = await embeddingAdapter.embed(params.vector.text, "query", signal);
+  let raw;
+  try {
+    raw = await embeddingAdapter.embed(params.vector.text, "query", signal);
+  } catch (err) {
+    if (err instanceof NarsilError) throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new NarsilError(ErrorCodes.EMBEDDING_FAILED, `The embedding adapter cannot embed the query: ${message}`, {
+      cause: message
+    });
+  }
   if (!(raw instanceof Float32Array)) {
     throw new NarsilError(
       ErrorCodes.EMBEDDING_FAILED,

package/dist/{chunk-RGS7FMCB.mjs → chunk-VMRR3DQU.mjs}

@@ -1,6 +1,6 @@
-import { MAX_SORT_FIELDS } from './chunk-L225SHNB.mjs';
-import { nativeSearchCoreIsEnabled, loadNativeCore } from './chunk-UTOFOJOR.mjs';
-import { NarsilError, ServerErrorCodes, ErrorCodes } from './chunk-FRQVMFY7.mjs';
+import { MAX_SORT_FIELDS } from './chunk-L6TNPLAR.mjs';
+import { nativeSearchCoreIsEnabled, loadNativeCore } from './chunk-YNVIUGF5.mjs';
+import { NarsilError, ServerErrorCodes, ErrorCodes } from './chunk-USKFU7J5.mjs';
 
 // src/server/capabilities.ts
 var ASYNC_IMPORT_CAPABILITY = "documents.import.async";
@@ -68,14 +68,21 @@ function matchOrigin(cors, requestOrigin) {
   if (typeof cors.origin === "string") return cors.origin;
   return cors.origin.includes(requestOrigin) ? requestOrigin : null;
 }
-function writeCorsOrigin(res, cors, requestOrigin) {
+function corsOriginHeaders(cors, requestOrigin) {
   const allowed = matchOrigin(cors, requestOrigin);
-  if (!allowed) return;
-  res.writeHeader("Access-Control-Allow-Origin", allowed);
-  if (allowed !== "*") res.writeHeader("Vary", "Origin");
+  const variesByOrigin = Array.isArray(cors.origin);
+  if (!allowed) return variesByOrigin ? [["Vary", "Origin"]] : [];
+  if (!variesByOrigin) return [["Access-Control-Allow-Origin", allowed]];
+  return [
+    ["Access-Control-Allow-Origin", allowed],
+    ["Vary", "Origin"]
+  ];
+}
+function writeCorsOrigin(res, cors, requestOrigin) {
+  for (const [key, value] of corsOriginHeaders(cors, requestOrigin)) res.writeHeader(key, value);
 }
-function corsWriter(cors) {
-  return (res, req) => writeCorsOrigin(res, cors, req.getHeader("origin"));
+function corsHeaderReader(cors) {
+  return (req) => corsOriginHeaders(cors, req.getHeader("origin"));
 }
 
 // src/server/errors.ts
@@ -116,6 +123,7 @@ var STATUS_BY_CODE = {
   INDEX_ALREADY_EXISTS: 409,
   INDEX_ORPHANED: 409,
   INDEX_REOPEN_CAPACITY_EXHAUSTED: 503,
+  INSTANCE_SHUT_DOWN: 503,
   DOC_ALREADY_EXISTS: 409,
   PARTITION_REBALANCING_BACKPRESSURE: 409,
   PARTITION_CAPACITY_EXCEEDED: 409,
@@ -703,6 +711,54 @@ function decodePathParameter(raw) {
     return null;
   }
 }
+function sinkWritingAfterStatus(res, headers) {
+  if (headers.length === 0) return res;
+  const sink = {
+    cork(callback) {
+      res.cork(callback);
+      return sink;
+    },
+    writeStatus(status) {
+      res.writeStatus(status);
+      for (const [key, value] of headers) res.writeHeader(key, value);
+      return sink;
+    },
+    writeHeader(key, value) {
+      res.writeHeader(key, value);
+      return sink;
+    },
+    end(body) {
+      res.end(body);
+      return sink;
+    },
+    endWithoutBody() {
+      res.endWithoutBody();
+      return sink;
+    },
+    tryEnd(body, totalSize) {
+      return res.tryEnd(body, totalSize);
+    },
+    getWriteOffset() {
+      return res.getWriteOffset();
+    },
+    onWritable(handler) {
+      res.onWritable(handler);
+      return sink;
+    },
+    onAborted(handler) {
+      res.onAborted(handler);
+      return sink;
+    },
+    onData(handler) {
+      res.onData(handler);
+      return sink;
+    },
+    getRemoteAddressAsText() {
+      return res.getRemoteAddressAsText();
+    }
+  };
+  return sink;
+}
 function isDenial(value) {
   return typeof value === "object" && value !== null && "status" in value;
 }
@@ -726,13 +782,14 @@ function sendDenial(res, authorization) {
   sendError(res, authorization.denial.status, authorization.denial.code, authorization.denial.message);
 }
 function createRouteRunner(deps) {
-  const { authorize, gate, writeCors } = deps;
+  const { authorize, gate, corsHeaders } = deps;
   return (handler, opts) => {
     const paramCount = opts.paramCount ?? 0;
     const needsBody = opts.needsBody ?? false;
     const useHook = authorize !== void 0 && !opts.skipHooks;
     const gated = !opts.skipHooks;
-    return (res, req) => {
+    return (response, req) => {
+      const res = corsHeaders ? sinkWritingAfterStatus(response, corsHeaders(req)) : response;
       const params = [];
       let malformed = null;
       for (let i = 0; i < paramCount; i++) {
@@ -753,13 +810,12 @@ function createRouteRunner(deps) {
           headers[key] = value;
         });
         hookContext = {
-          method: req.getMethod(),
+          method: req.getMethod().toUpperCase(),
           path: req.getUrl(),
           headers,
           remoteAddress: Buffer.from(res.getRemoteAddressAsText()).toString()
         };
       }
-      if (writeCors) writeCors(res, req);
       const abort = initAbortHandler(res);
       if (malformed !== null) {
         sendError(
@@ -877,8 +933,10 @@ function registerServerRoutes(app, run, handlers, limits, cors) {
   for (const route of serverRoutes(limits)) {
     app[route.method](route.path, run(handlers[route.handler], route.options));
   }
-  app.any("/*", (res) => {
-    sendError(res, 404, ServerErrorCodes.NOT_FOUND, "Route not found");
+  const corsHeaders = cors ? corsHeaderReader(cors) : null;
+  app.any("/*", (res, req) => {
+    const sink = corsHeaders === null ? res : sinkWritingAfterStatus(res, corsHeaders(req));
+    sendError(sink, 404, ServerErrorCodes.NOT_FOUND, "Route not found");
   });
 }
 
@@ -916,4 +974,4 @@ function childAppOf(app) {
   return candidate;
 }
 
-export { ASYNC_IMPORT_CAPABILITY, DEFAULT_IMPORT_BATCH_SIZE, DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_MAX_CONCURRENT_TASKS, DEFAULT_MAX_FETCH_DOCUMENTS, DEFAULT_MAX_IMPORT_BYTES, DEFAULT_MAX_IMPORT_ERRORS, DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_RESULT_WINDOW, DEFAULT_MAX_RETAINED_TASKS, DEFAULT_MAX_TASK_PAGE_SIZE, DEFAULT_TASK_PAGE_SIZE, IMPORT_FLUSHES_IN_FLIGHT, INDEX_LIFECYCLE_CAPABILITY, INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT, MAIN_THREAD_GATE_SLOT, MAX_INDEX_TOUCH_INTERVAL_MS, MIN_COUNTED_SERVER_LIMIT, MIN_UNBOUNDED_SERVER_LIMIT, REBUILD_ANALYSIS_CAPABILITY, RUNNING_TASK_TTL_MS, SERVER_CAPABILITIES, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, TASK_PROGRESS_WRITE_INTERVAL_MS, TERMINAL_TASK_TTL_MS, acceptorOf, authorizerFor, badRequest, childAppOf, clearGateSlot, corsWriter, createDocumentReadHandlers, createRouteRunner, createSharedGateBuffer, createSharedRequestGate, createVersionHandler, gateSlotOfWorker, httpStatusForNarsilError, loadUWebSockets, parseJson, parseJsonOptional, parseTaskListQuery, registerServerRoutes, rejectInvalid, resolveCors, respondError, respondJson, sendBinary, sendError, sendRelayed, serializeBatchResult, serializeNarsilError, serverRoutes, toHttpError, validateBatch, validateCreateIndex, validateDocumentBody, validateQuery, validateRebalance, validateSuggest, versionReport };
+export { ASYNC_IMPORT_CAPABILITY, DEFAULT_IMPORT_BATCH_SIZE, DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_MAX_CONCURRENT_TASKS, DEFAULT_MAX_FETCH_DOCUMENTS, DEFAULT_MAX_IMPORT_BYTES, DEFAULT_MAX_IMPORT_ERRORS, DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_RESULT_WINDOW, DEFAULT_MAX_RETAINED_TASKS, DEFAULT_MAX_TASK_PAGE_SIZE, DEFAULT_TASK_PAGE_SIZE, IMPORT_FLUSHES_IN_FLIGHT, INDEX_LIFECYCLE_CAPABILITY, INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT, MAIN_THREAD_GATE_SLOT, MAX_INDEX_TOUCH_INTERVAL_MS, MIN_COUNTED_SERVER_LIMIT, MIN_UNBOUNDED_SERVER_LIMIT, REBUILD_ANALYSIS_CAPABILITY, RUNNING_TASK_TTL_MS, SERVER_CAPABILITIES, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, TASK_PROGRESS_WRITE_INTERVAL_MS, TERMINAL_TASK_TTL_MS, acceptorOf, authorizerFor, badRequest, childAppOf, clearGateSlot, corsHeaderReader, createDocumentReadHandlers, createRouteRunner, createSharedGateBuffer, createSharedRequestGate, createVersionHandler, gateSlotOfWorker, httpStatusForNarsilError, loadUWebSockets, parseJson, parseJsonOptional, parseTaskListQuery, registerServerRoutes, rejectInvalid, resolveCors, respondError, respondJson, sendBinary, sendError, sendRelayed, serializeBatchResult, serializeNarsilError, serverRoutes, toHttpError, validateBatch, validateCreateIndex, validateDocumentBody, validateQuery, validateRebalance, validateSuggest, versionReport };

package/dist/{chunk-2GWVQWGA.mjs → chunk-YMZCMH5M.mjs}

@@ -112,6 +112,16 @@ function compareSortStrings(a, b) {
 var SORT_VALUE_MAX_CODE_POINTS = 512;
 
 // src/core/ordering/sort-values.ts
+var SORT_MODES = ["min", "max", "avg", "median"];
+function isSortMode(value) {
+  return value === "min" || value === "max" || value === "avg" || value === "median";
+}
+function defaultSortMode(direction) {
+  return direction === "desc" ? "max" : "min";
+}
+function sortModeOf(entry) {
+  return entry.mode ?? defaultSortMode(entry.direction);
+}
 function truncateSortString(value) {
   if (value.length <= SORT_VALUE_MAX_CODE_POINTS) return value;
   let index = 0;
@@ -133,6 +143,40 @@ function toComparableSortValue(value) {
   if (typeof value === "boolean") return value;
   return null;
 }
+function numericReduction(values, mode) {
+  const numbers = [];
+  for (const element of values) {
+    if (typeof element === "number" && Number.isFinite(element)) numbers.push(element);
+  }
+  if (numbers.length === 0) return null;
+  if (mode === "avg") {
+    let mean = 0;
+    for (let index = 0; index < numbers.length; index++) {
+      mean += (numbers[index] - mean) / (index + 1);
+    }
+    return mean;
+  }
+  numbers.sort((a, b) => a - b);
+  const middle = numbers.length >> 1;
+  if (numbers.length % 2 === 1) return numbers[middle];
+  return numbers[middle - 1] / 2 + numbers[middle] / 2;
+}
+function toReducedSortValue(value, mode) {
+  if (!Array.isArray(value)) return toComparableSortValue(value);
+  if (mode === "avg" || mode === "median") return numericReduction(value, mode);
+  let chosen = null;
+  for (const element of value) {
+    const comparable = toComparableSortValue(element);
+    if (comparable === null) continue;
+    if (chosen === null) {
+      chosen = comparable;
+      continue;
+    }
+    const comparison = comparePresentValues(comparable, chosen);
+    if (mode === "min" ? comparison < 0 : comparison > 0) chosen = comparable;
+  }
+  return chosen;
+}
 function readSortField(document, path) {
   const segments = path.split(".");
   let current = document;
@@ -184,4 +228,4 @@ function compareSortValues(aValues, bValues, directions) {
   return 0;
 }
 
-export { SORT_VALUE_MAX_CODE_POINTS, compareCodePoints, compareComparableKeys, compareComparableValues, compareSortValues, readSortField, toComparableSortValue };
+export { SORT_MODES, SORT_VALUE_MAX_CODE_POINTS, compareCodePoints, compareComparableKeys, compareComparableValues, compareSortValues, defaultSortMode, isSortMode, readSortField, sortModeOf, toComparableSortValue, toReducedSortValue };

package/dist/{chunk-UTOFOJOR.mjs → chunk-YNVIUGF5.mjs}

@@ -1,4 +1,4 @@
-import { NarsilError, ErrorCodes } from './chunk-FRQVMFY7.mjs';
+import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
 import { existsSync } from 'fs';
 import { createRequire } from 'module';
 import { join, dirname } from 'path';
@@ -119,6 +119,10 @@ function coreAt(path) {
   }
   return core;
 }
+function requireSearchBackendSettings() {
+  requestedBackend();
+  if (process.env.NARSIL_REQUIRE_NATIVE_CORE === "1") loadNativeCore();
+}
 function loadNativeCore() {
   if (loaded !== void 0) return loaded;
   if (requestedBackend() === "wasm") {
@@ -132,4 +136,4 @@ function loadNativeCore() {
   return loaded;
 }
 
-export { COMPACTION_ABSOLUTE_THRESHOLD, COMPACTION_TOMBSTONE_RATIO, DEFAULT_EF_SEARCH, INITIAL_LIST_CAPACITY, INITIAL_UPPER_SLOTS, MAX_LAYER_CAP, MAX_M, PLACEMENT_ROOM_REQUESTS, loadNativeCore, nativeSearchCoreIsEnabled, noteFallback, stopUsingTheNativeSearchCore };
+export { COMPACTION_ABSOLUTE_THRESHOLD, COMPACTION_TOMBSTONE_RATIO, DEFAULT_EF_SEARCH, INITIAL_LIST_CAPACITY, INITIAL_UPPER_SLOTS, MAX_LAYER_CAP, MAX_M, PLACEMENT_ROOM_REQUESTS, loadNativeCore, nativeSearchCoreIsEnabled, noteFallback, requireSearchBackendSettings, stopUsingTheNativeSearchCore };