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

package/dist/{chunk-HWQLTLNG.mjs → chunk-4MQ5F4IL.mjs}

@@ -1,5 +1,5 @@
 import { english } from './chunk-TGP5M5R7.mjs';
-import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
+import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 
 // src/languages/registry.ts
 var languages = /* @__PURE__ */ new Map();

package/dist/{chunk-FVLQ63B7.mjs → chunk-AFKH4ZK3.mjs}

@@ -1,5 +1,5 @@
-import { validateRequiredFields } from './chunk-653BNMAF.mjs';
-import { ErrorCodes, NarsilError } from './chunk-USKFU7J5.mjs';
+import { requireDocumentWithinSizeLimit, validateRequiredFields } from './chunk-AK3BLGCI.mjs';
+import { ErrorCodes, NarsilError } from './chunk-I64LXKO3.mjs';
 
 // src/narsil/internals.ts
 var engineCores = /* @__PURE__ */ new WeakMap();
@@ -239,9 +239,33 @@ async function embedBatchDocumentFields(documents, embeddingConfig, adapter, sig
 
 // src/engine/mutations/insert-admission.ts
 function providedDocId(document) {
+  if (document === null || typeof document !== "object") return void 0;
   const id = document.id;
   return typeof id === "string" && id.length > 0 ? id : void 0;
 }
+function requireDocumentObject(document) {
+  if (document !== null && typeof document === "object" && !Array.isArray(document)) {
+    requireDocumentWithinSizeLimit(document);
+    return;
+  }
+  const received = Array.isArray(document) ? "a list" : document === null ? "null" : `a ${typeof document}`;
+  throw new NarsilError(
+    ErrorCodes.DOC_VALIDATION_FAILED,
+    `Each document must be an object, while this entry is ${received}`,
+    {
+      received
+    }
+  );
+}
+function requireMatchingDocId(docId, document) {
+  const embeddedDocId = providedDocId(document);
+  if (embeddedDocId === void 0 || embeddedDocId === docId) return;
+  throw new NarsilError(
+    ErrorCodes.DOC_VALIDATION_FAILED,
+    `The call names document id "${docId}" while the document's own id field is "${embeddedDocId}", so the stored document would contradict the key that it is stored under`,
+    { docId, documentId: embeddedDocId }
+  );
+}
 function asBatchInsertError(err) {
   return err instanceof NarsilError ? err : new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, String(err));
 }
@@ -557,13 +581,13 @@ function readSharedConfigFields(source, reject) {
     ...typeof source.patternValueLimit === "number" ? { patternValueLimit: source.patternValueLimit } : {}
   };
 }
-function restoredConfigFields(envelope) {
-  const shared = readSharedConfigFields(envelope, rejectSnapshot);
-  const partitions = restoredPartitionConfig(envelope.partitionConfig);
+function restoredConfigFields(envelope, reject = rejectSnapshot) {
+  const shared = readSharedConfigFields(envelope, reject);
+  const partitions = restoredPartitionConfig(envelope.partitionConfig, reject);
   return {
     ...shared,
     ...partitions !== void 0 ? { partitions } : {}
   };
 }
 
-export { MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR, WIRE_BATCH_BUDGET, admitBufferedUpsert, admitInsert, asBatchInsertError, assertDocumentCarriesMappedVectors, bindEngineCore, collectRequiredFieldFailures, createPendingAdmissions, embedChunkDocuments, embedDocumentFields, engineCoreOf, providedDocId, readSharedConfigFields, recordPendingAdmission, resolveVectorText, restoredConfigFields, restoredEmbedding, restoredPartitionConfig };
+export { MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR, WIRE_BATCH_BUDGET, admitBufferedUpsert, admitInsert, asBatchInsertError, assertDocumentCarriesMappedVectors, bindEngineCore, collectRequiredFieldFailures, createPendingAdmissions, embedChunkDocuments, embedDocumentFields, engineCoreOf, providedDocId, readSharedConfigFields, recordPendingAdmission, requireDocumentObject, requireMatchingDocId, resolveVectorText, restoredConfigFields, restoredEmbedding, restoredPartitionConfig };

package/dist/{chunk-653BNMAF.mjs → chunk-AK3BLGCI.mjs}

@@ -1,6 +1,7 @@
-import { MAX_M } from './chunk-YNVIUGF5.mjs';
-import { exceedsCodePoints } from './chunk-OI42GWLR.mjs';
-import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
+import { EARLIER_RELEASE_MIN_M, MIN_M, MAX_M } from './chunk-PU43WDY4.mjs';
+import { holdsUnpairedSurrogate, exceedsCodePoints } from './chunk-LJYTW7GT.mjs';
+import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
+import { encode } from '@msgpack/msgpack';
 
 // src/schema/constants.ts
 var MAX_NESTING_DEPTH = 4;
@@ -8,6 +9,10 @@ var MAX_DOCUMENT_NESTING_DEPTH = 32;
 var DEFAULT_PATTERN_VALUE_LIMIT = 8192;
 var MIN_PATTERN_VALUE_LIMIT = 1;
 var MAX_PATTERN_VALUE_LIMIT = 65536;
+var MAX_VECTOR_DIMENSION = 4096;
+var MAX_STORED_VECTOR_DIMENSION = 65535;
+var MAX_TEXT_FIELDS = 65536;
+var MAX_DOCUMENT_BYTES = 16777216;
 
 // src/schema/validator/shared.ts
 var VECTOR_PATTERN = /^vector\[(\d+)]$/;
@@ -57,11 +62,11 @@ function parseBase(baseName, path, type) {
     invalidType(path, type, `Field "${path}" has an unsupported type: "${type}"`);
   }
   const dimension = Number.parseInt(vectorMatch[1], 10);
-  if (dimension <= 0) {
+  if (dimension <= 0 || dimension > MAX_STORED_VECTOR_DIMENSION) {
     throw new NarsilError(
       ErrorCodes.SCHEMA_INVALID_VECTOR_DIMENSION,
-      `Vector field "${path}" must have a positive dimension, got ${dimension}`,
-      { field: path, dimension }
+      `Vector field "${path}" has ${dimension} dimensions, but a vector field holds from 1 to ${MAX_STORED_VECTOR_DIMENSION}`,
+      { field: path, dimension, maximum: MAX_STORED_VECTOR_DIMENSION }
     );
   }
   return { base: "vector", dimension };
@@ -194,9 +199,30 @@ function validateSchema(schema) {
   if (Object.keys(schema).length === 0) {
     throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must define at least one field");
   }
-  return validateSchemaFields(schema, 1, "");
+  const validated = validateSchemaFields(schema, 1, "");
+  requireTextFieldCount(schemaFieldsOf(validated).filter((field) => isWordIndexedBase(field.base)).length);
+  return validated;
+}
+function requireTextFieldCount(count) {
+  if (count <= MAX_TEXT_FIELDS) return;
+  throw new NarsilError(
+    ErrorCodes.SCHEMA_INVALID_TYPE,
+    `The schema declares ${count} string and string[] fields, but a schema holds at most ${MAX_TEXT_FIELDS}`,
+    { textFields: count, maximum: MAX_TEXT_FIELDS }
+  );
+}
+function requireCreatableSchema(schema) {
+  for (const field of schemaFieldsOf(schema)) {
+    if (field.base !== "vector" || field.dimension <= MAX_VECTOR_DIMENSION) continue;
+    throw new NarsilError(
+      ErrorCodes.SCHEMA_INVALID_VECTOR_DIMENSION,
+      `Vector field "${field.path}" has ${field.dimension} dimensions, but a new index takes at most ${MAX_VECTOR_DIMENSION}`,
+      { field: field.path, dimension: field.dimension, maximum: MAX_VECTOR_DIMENSION }
+    );
+  }
 }
 function requireValidFieldTypes(flatSchema) {
+  let textFields = 0;
   for (const [path, type] of Object.entries(flatSchema)) {
     if (typeof type !== "string") {
       throw new NarsilError(
@@ -205,8 +231,9 @@ function requireValidFieldTypes(flatSchema) {
         { field: path, type: String(type) }
       );
     }
-    parseFieldType(type, path);
+    if (isWordIndexedBase(parseFieldType(type, path).base)) textFields += 1;
   }
+  requireTextFieldCount(textFields);
 }
 function flattenRecursive(schema, prefix, result) {
   for (const [field, type] of Object.entries(schema)) {
@@ -247,6 +274,29 @@ function extractVectorFieldsFromSchema(schema) {
   return result;
 }
 
+// src/geo/constants.ts
+var DEG_TO_RAD = Math.PI / 180;
+var MAX_LATITUDE_DEGREES = 90;
+var MAX_LONGITUDE_DEGREES = 180;
+var MIN_POLYGON_POINTS = 3;
+var ANTIMERIDIAN_SPAN_DEGREES = 180;
+var FULL_TURN_DEGREES = 360;
+var EARTH_RADIUS_METERS = 63710088e-1;
+var LOCATION_CODE_BITS_PER_AXIS = 26;
+var MAX_COVERING_CELLS = 16;
+var RADIUS_BOX_MARGIN_RATIO = 1.02;
+var RADIUS_BOX_MARGIN_RADIANS = 1e-9;
+var VINCENTY_MAX_ITERATIONS = 200;
+var VINCENTY_CONVERGENCE_THRESHOLD = 1e-12;
+
+// src/geo/coordinates.ts
+function isLatitude(value) {
+  return value >= -MAX_LATITUDE_DEGREES && value <= MAX_LATITUDE_DEGREES;
+}
+function isLongitude(value) {
+  return value >= -MAX_LONGITUDE_DEGREES && value <= MAX_LONGITUDE_DEGREES;
+}
+
 // src/schema/validator/field-values.ts
 function validateGeopoint(path, value) {
   if (!isPlainObject(value)) {
@@ -266,7 +316,7 @@ function validateGeopoint(path, value) {
       lon: Number.isNaN(value.lon) ? "NaN" : typeof value.lon
     });
   }
-  if (value.lat < -90 || value.lat > 90) {
+  if (!isLatitude(value.lat)) {
     throw new NarsilError(
       ErrorCodes.SCHEMA_INVALID_GEOPOINT,
       `Field "${path}" geopoint lat must be between -90 and 90`,
@@ -276,7 +326,7 @@ function validateGeopoint(path, value) {
       }
     );
   }
-  if (value.lon < -180 || value.lon > 180) {
+  if (!isLongitude(value.lon)) {
     throw new NarsilError(
       ErrorCodes.SCHEMA_INVALID_GEOPOINT,
       `Field "${path}" geopoint lon must be between -180 and 180`,
@@ -306,7 +356,7 @@ function validateVector(path, value, expectedDimension) {
     );
   }
   for (let i = 0; i < arr.length; i++) {
-    if (typeof arr[i] !== "number" || Number.isNaN(arr[i])) {
+    if (typeof arr[i] !== "number" || !Number.isFinite(arr[i])) {
       throw new NarsilError(
         ErrorCodes.DOC_VALIDATION_FAILED,
         `Field "${path}" vector element at index ${i} is not a valid number`,
@@ -331,11 +381,12 @@ function validateTypedArray(path, value, elementType) {
         { field: path, index: i, expected: elementType, received: typeof el }
       );
     }
-    if (elementType === "number" && Number.isNaN(el)) {
-      throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" array element at index ${i} is NaN`, {
-        field: path,
-        index: i
-      });
+    if (elementType === "number" && !Number.isFinite(el)) {
+      throw new NarsilError(
+        ErrorCodes.DOC_VALIDATION_FAILED,
+        `Field "${path}" array element at index ${i} is ${String(el)}, while a number field holds finite numbers alone`,
+        { field: path, index: i }
+      );
     }
   }
 }
@@ -366,11 +417,11 @@ function validateFieldValue(path, value, type, patternValueLimit) {
       if (type.pattern) validatePatternValue(path, value, patternValueLimit);
       return;
     case "number":
-      if (typeof value !== "number" || Number.isNaN(value)) {
-        throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected a valid number`, {
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected a finite number`, {
           field: path,
           expected: "number",
-          received: Number.isNaN(value) ? "NaN" : typeof value
+          received: typeof value === "number" ? String(value) : typeof value
         });
       }
       return;
@@ -428,6 +479,7 @@ function validateFieldValue(path, value, type, patternValueLimit) {
 
 // src/schema/validator/storable.ts
 var RESERVED_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var UNPAIRED_SURROGATE_REASON = "holds an unpaired surrogate, the half of a character such as an emoji whose other half is missing, so the engine cannot store it as UTF-8";
 function reject(path, reason) {
   throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path === "" ? "(document)" : path}" ${reason}`, {
     field: path
@@ -440,13 +492,20 @@ function isPlainObject2(value) {
 function walkStorable(value, path, depth, ancestors, skip) {
   if (value === null || value === void 0) return;
   const kind = typeof value;
-  if (kind === "string" || kind === "boolean") return;
-  if (kind === "number") return;
+  if (kind === "string") {
+    if (holdsUnpairedSurrogate(value)) reject(path, UNPAIRED_SURROGATE_REASON);
+    return;
+  }
+  if (kind === "boolean" || kind === "number") return;
   if (kind === "bigint" || kind === "symbol" || kind === "function") {
     reject(path, `holds a ${kind}, which cannot be stored or recovered`);
   }
   const container = value;
-  if (container instanceof Date || container instanceof Uint8Array) return;
+  if (container instanceof Date) {
+    if (Number.isNaN(container.getTime())) reject(path, "holds an invalid date, which the engine cannot store");
+    return;
+  }
+  if (container instanceof Uint8Array) return;
   const isArray = Array.isArray(container);
   if (!isArray && !isPlainObject2(container)) {
     reject(
@@ -473,6 +532,7 @@ function walkStorable(value, path, depth, ancestors, skip) {
       if (RESERVED_OBJECT_KEYS.has(key)) {
         reject(keyPath, "uses a reserved object key");
       }
+      if (holdsUnpairedSurrogate(key)) reject(keyPath, `has a name that ${UNPAIRED_SURROGATE_REASON}`);
       if (skip.has(keyPath)) continue;
       walkStorable(record[key], keyPath, depth + 1, ancestors, skip);
     }
@@ -539,9 +599,20 @@ function validateDocument(document, schema, patternValueLimit = DEFAULT_PATTERN_
       received: typeof document
     });
   }
+  requireIdFieldKey(document);
   assertStorableDocument(document, vectorFieldPaths(schema));
   validateDocumentFields(document, schema, "", patternValueLimit);
 }
+function requireIdFieldKey(document) {
+  if (!Object.hasOwn(document, "id")) return;
+  const id = document.id;
+  if (typeof id === "string" && id.length > 0) return;
+  throw new NarsilError(
+    ErrorCodes.DOC_VALIDATION_FAILED,
+    `Field "id" holds ${typeof id === "string" ? "an empty string" : id === null ? "null" : `a ${typeof id}`}, while the engine stores a document under its id field, so that field must hold a non-empty string`,
+    { field: "id", received: id === null ? "null" : typeof id }
+  );
+}
 function collectExtraFields(doc, schema, prefix, extras) {
   for (const key of Object.keys(doc)) {
     if (key === "id") continue;
@@ -588,6 +659,71 @@ function validateRequiredFields(document, required) {
     }
   }
 }
+function holdsNegativeZero(value) {
+  const pending = [value];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (typeof next === "number") {
+      if (Object.is(next, -0)) return true;
+      continue;
+    }
+    if (next === null || typeof next !== "object" || ArrayBuffer.isView(next)) continue;
+    for (const child of Array.isArray(next) ? next : Object.values(next)) pending.push(child);
+  }
+  return false;
+}
+function encodeDocument(document) {
+  return encode(document, holdsNegativeZero(document) ? { forceIntegerToFloat: true } : void 0);
+}
+
+// src/schema/validator/document-size.ts
+var LARGEST_HEADER_BYTES = 5;
+var LARGEST_NUMBER_BYTES = 9;
+var LARGEST_TIMESTAMP_BYTES = 15;
+var LARGEST_UTF8_BYTES_PER_UNIT = 3;
+function upperBoundBytes(value, budget, depth) {
+  if (value === null || value === void 0 || typeof value === "boolean") return 1;
+  if (typeof value === "number") return LARGEST_NUMBER_BYTES;
+  if (typeof value === "string") return LARGEST_HEADER_BYTES + value.length * LARGEST_UTF8_BYTES_PER_UNIT;
+  if (value instanceof Date) return LARGEST_TIMESTAMP_BYTES;
+  if (ArrayBuffer.isView(value)) return LARGEST_HEADER_BYTES + value.byteLength;
+  if (typeof value !== "object" || depth > MAX_DOCUMENT_NESTING_DEPTH) return LARGEST_NUMBER_BYTES;
+  let total = LARGEST_HEADER_BYTES;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      total += upperBoundBytes(item, budget - total, depth + 1);
+      if (total > budget) return total;
+    }
+    return total;
+  }
+  const record = value;
+  for (const key of Object.keys(record)) {
+    total += LARGEST_HEADER_BYTES + key.length * LARGEST_UTF8_BYTES_PER_UNIT;
+    total += upperBoundBytes(record[key], budget - total, depth + 1);
+    if (total > budget) return total;
+  }
+  return total;
+}
+function messagePackUpperBoundBytes(value) {
+  return upperBoundBytes(value, Number.POSITIVE_INFINITY, 0);
+}
+function encodedBytesOf(document) {
+  try {
+    return encodeDocument(document).byteLength;
+  } catch {
+    return null;
+  }
+}
+function requireDocumentWithinSizeLimit(document) {
+  if (upperBoundBytes(document, MAX_DOCUMENT_BYTES, 0) <= MAX_DOCUMENT_BYTES) return;
+  const encodedBytes = encodedBytesOf(document);
+  if (encodedBytes === null || encodedBytes <= MAX_DOCUMENT_BYTES) return;
+  throw new NarsilError(
+    ErrorCodes.DOC_VALIDATION_FAILED,
+    `The document takes ${encodedBytes} bytes as MessagePack, vector values included, but a document may take at most ${MAX_DOCUMENT_BYTES}`,
+    { bytes: encodedBytes, maximum: MAX_DOCUMENT_BYTES }
+  );
+}
 
 // src/schema/validator/vector-promotion.ts
 var QUANTIZATION_MODES = /* @__PURE__ */ new Set(["osq8", "osq4", "osq2", "osq1", "none"]);
@@ -611,6 +747,13 @@ function validateVectorStorage(config, filesystemDurability) {
     });
   }
 }
+function raiseEarlierReleaseGraphSetting(config) {
+  if (typeof config !== "object" || config === null) return config;
+  const hnsw = config.hnswConfig;
+  if (typeof hnsw !== "object" || hnsw === null) return config;
+  if (hnsw.m !== EARLIER_RELEASE_MIN_M) return config;
+  return { ...config, hnswConfig: { ...hnsw, m: MIN_M } };
+}
 function validateVectorPromotion(config) {
   if (config === void 0) return;
   if (config.threshold !== void 0 && !isPositiveInteger(config.threshold)) {
@@ -626,8 +769,8 @@ function validateVectorPromotion(config) {
   }
   const hnsw = config.hnswConfig;
   if (hnsw === void 0) return;
-  if (hnsw.m !== void 0 && (!isPositiveInteger(hnsw.m) || hnsw.m > MAX_M)) {
-    fail(`vectorPromotion.hnswConfig.m must be a positive integer no greater than ${MAX_M}`, { m: hnsw.m });
+  if (hnsw.m !== void 0 && (!Number.isInteger(hnsw.m) || hnsw.m < MIN_M || hnsw.m > MAX_M)) {
+    fail(`vectorPromotion.hnswConfig.m must be a whole number from ${MIN_M} to ${MAX_M}`, { m: hnsw.m });
   }
   if (hnsw.efConstruction !== void 0 && !isPositiveInteger(hnsw.efConstruction)) {
     fail("vectorPromotion.hnswConfig.efConstruction must be a positive integer", {
@@ -658,4 +801,31 @@ var DEFAULT_LINEAR_ALPHA = 0.5;
 var MIN_LINEAR_ALPHA = 0;
 var MAX_LINEAR_ALPHA = 1;
 
-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_PATTERN_VALUE_LIMIT, MAX_PREFIX_LENGTH, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_TOLERANCE, MIN_LINEAR_ALPHA, MIN_PATTERN_VALUE_LIMIT, MIN_RANK_CONSTANT, PREFIX_MAX_EXPANSIONS, PROTOTYPE_POLLUTION_KEYS, RESULT_WINDOW, VECTOR_PATTERN, extractVectorFieldsFromSchema, flattenSchema, isGeopointOrVectorType, isListBase, isQuantizationMode, isSingleStringFieldType, isStorageMode, isStringValuedBase, isWordIndexedBase, isWordIndexedFieldType, parsedTypeOf, requireValidFieldTypes, schemaFieldsOf, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion, validateVectorStorage, withSortableOption };
+// src/engine/constants.ts
+var MIN_DOCUMENTS_FOR_SEGMENTS = 64;
+var BATCH_CHUNK_SIZE = 1e3;
+var DEFAULT_LIMIT = DEFAULT_PAGE_SIZE;
+var DEFAULT_OFFSET = 0;
+var INDEX_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var ABSOLUTE_WINDOWS_PATH_PATTERN = /^[a-zA-Z]:[\\/]/;
+var MODULE_URL_SCHEME_PATTERN = /^(file|https?|data|node):/;
+var MAX_INDEX_NAME_LENGTH = 255;
+var MAX_DOC_ID_LENGTH = 512;
+var EXPORT_CHUNK_BYTES = 1048576;
+var MAX_EXPORT_LINE_BYTES = 117443592;
+var MAX_INDEX_CONFIGURATION_BYTES = 16777216;
+var IMPORT_BATCH_DOCUMENTS = 1e3;
+var MAX_IMPORT_REFUSALS_REPORTED = 1e3;
+var MIN_SWEEP_INTERVAL_MS = 100;
+var MAX_SWEEP_INTERVAL_MS = 6e4;
+var HEAP_PRESSURE_WARNING_FRACTION = 0.9;
+var HEAP_PRESSURE_REARM_FRACTION = 0.8;
+var STATISTICS_BROADCAST_INTERVAL_MS = 5e3;
+var FOREIGN_STATS_TTL_MS = 6e4;
+var DEFAULT_SUGGEST_LIMIT = 10;
+var MAX_SUGGEST_LIMIT = 100;
+var SUGGEST_OVERSAMPLE_FACTOR = 1.5;
+var SUGGEST_OVERSAMPLE_PADDING = 10;
+var MAX_SUGGEST_SCATTER_LIMIT = Math.ceil(MAX_SUGGEST_LIMIT * SUGGEST_OVERSAMPLE_FACTOR) + SUGGEST_OVERSAMPLE_PADDING;
+
+export { ABSOLUTE_WINDOWS_PATH_PATTERN, ANTIMERIDIAN_SPAN_DEGREES, BATCH_CHUNK_SIZE, DEFAULT_FUZZY_PREFIX_LENGTH, DEFAULT_LIMIT, DEFAULT_LINEAR_ALPHA, DEFAULT_MAX_PER_GROUP, DEFAULT_OFFSET, DEFAULT_PAGE_SIZE, DEFAULT_RANK_CONSTANT, DEFAULT_SUGGEST_LIMIT, DEG_TO_RAD, EARTH_RADIUS_METERS, EXPORT_CHUNK_BYTES, FOREIGN_STATS_TTL_MS, FULL_TURN_DEGREES, HEAP_PRESSURE_REARM_FRACTION, HEAP_PRESSURE_WARNING_FRACTION, IMPORT_BATCH_DOCUMENTS, INDEX_NAME_PATTERN, LOCATION_CODE_BITS_PER_AXIS, MAX_COVERING_CELLS, MAX_CURSOR_ANCHOR_CODE_POINTS, MAX_CURSOR_LENGTH, MAX_DOCUMENT_NESTING_DEPTH, MAX_DOC_ID_LENGTH, MAX_EXPORT_LINE_BYTES, MAX_IMPORT_REFUSALS_REPORTED, MAX_INDEX_CONFIGURATION_BYTES, MAX_INDEX_NAME_LENGTH, MAX_LATITUDE_DEGREES, MAX_LINEAR_ALPHA, MAX_LONGITUDE_DEGREES, MAX_NESTING_DEPTH, MAX_PATTERN_VALUE_LIMIT, MAX_PREFIX_LENGTH, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_STORED_VECTOR_DIMENSION, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, MAX_SWEEP_INTERVAL_MS, MAX_TOLERANCE, MIN_DOCUMENTS_FOR_SEGMENTS, MIN_LINEAR_ALPHA, MIN_PATTERN_VALUE_LIMIT, MIN_POLYGON_POINTS, MIN_RANK_CONSTANT, MIN_SWEEP_INTERVAL_MS, MODULE_URL_SCHEME_PATTERN, PREFIX_MAX_EXPANSIONS, PROTOTYPE_POLLUTION_KEYS, RADIUS_BOX_MARGIN_RADIANS, RADIUS_BOX_MARGIN_RATIO, RESULT_WINDOW, STATISTICS_BROADCAST_INTERVAL_MS, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, VECTOR_PATTERN, VINCENTY_CONVERGENCE_THRESHOLD, VINCENTY_MAX_ITERATIONS, encodeDocument, extractVectorFieldsFromSchema, flattenSchema, isGeopointOrVectorType, isLatitude, isListBase, isLongitude, isQuantizationMode, isSingleStringFieldType, isStorageMode, isStringValuedBase, isWordIndexedBase, isWordIndexedFieldType, messagePackUpperBoundBytes, parsedTypeOf, raiseEarlierReleaseGraphSetting, requireCreatableSchema, requireDocumentWithinSizeLimit, requireValidFieldTypes, schemaFieldsOf, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion, validateVectorStorage, withSortableOption };