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

package/dist/{chunk-HWQLTLNG.mjs → chunk-KZTI25D3.mjs}

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

package/dist/{chunk-YJDQ7NLA.mjs → chunk-LCCL6EEH.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-YNVIUGF5.mjs';
-import { compareCodePoints } from './chunk-OI42GWLR.mjs';
-import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.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-P2ZZN32C.mjs';
+import { compareCodePoints } from './chunk-LJYTW7GT.mjs';
+import { NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
 import { readSync, closeSync, openSync } from 'fs';
 
 // src/vector/constants.ts

package/dist/{chunk-OI42GWLR.mjs → chunk-LJYTW7GT.mjs}

@@ -15,6 +15,31 @@ function exceedsCodePoints(value, maximum) {
   }
   return false;
 }
+var SURROGATE_UNIT = /[\ud800-\udfff]/;
+function holdsUnpairedSurrogate(value) {
+  if (!SURROGATE_UNIT.test(value)) return false;
+  for (let i = 0; i < value.length; i++) {
+    const unit = value.charCodeAt(i);
+    if (unit < 55296 || unit >= 57344) continue;
+    if (unit >= 56320) return true;
+    const low = value.charCodeAt(i + 1);
+    if (!(low >= 56320 && low < 57344)) return true;
+    i++;
+  }
+  return false;
+}
+function codePointCount(value) {
+  let counted = 0;
+  for (let i = 0; i < value.length; i++) {
+    const unit = value.charCodeAt(i);
+    if (unit >= 55296 && unit < 56320 && i + 1 < value.length) {
+      const low = value.charCodeAt(i + 1);
+      if (low >= 56320 && low < 57344) i++;
+    }
+    counted++;
+  }
+  return counted;
+}
 function adjustUtf16Unit(unit) {
   if (unit < 55296) return unit;
   if (unit < 57344) return unit + 8192;
@@ -65,6 +90,10 @@ function multiFoldTable() {
 
 // src/core/ordering/fold-compare.ts
 var EXHAUSTED = -1;
+function foldOf(codePoint, single, multi) {
+  if (codePoint < 128) return codePoint >= 65 && codePoint <= 90 ? codePoint + 32 : codePoint;
+  return single.get(codePoint) ?? multi.get(codePoint) ?? codePoint;
+}
 function nextFoldedCodePoint(text, cursor, single, multi) {
   if (cursor.pending !== null) {
     const cp2 = cursor.pending[cursor.pendingIndex];
@@ -78,9 +107,6 @@ function nextFoldedCodePoint(text, cursor, single, multi) {
   if (cursor.index >= text.length) return EXHAUSTED;
   let cp = text.charCodeAt(cursor.index);
   cursor.index++;
-  if (cp < 128) {
-    return cp >= 65 && cp <= 90 ? cp + 32 : cp;
-  }
   if (cp >= 55296 && cp < 56320 && cursor.index < text.length) {
     const low = text.charCodeAt(cursor.index);
     if (low >= 56320 && low < 57344) {
@@ -88,15 +114,13 @@ function nextFoldedCodePoint(text, cursor, single, multi) {
       cursor.index++;
     }
   }
-  const mapped = single.get(cp);
-  if (mapped !== void 0) return mapped;
-  const expansion = multi.get(cp);
-  if (expansion === void 0) return cp;
-  if (expansion.length > 1) {
-    cursor.pending = expansion;
+  const folded = foldOf(cp, single, multi);
+  if (typeof folded === "number") return folded;
+  if (folded.length > 1) {
+    cursor.pending = folded;
     cursor.pendingIndex = 1;
   }
-  return expansion[0];
+  return folded[0];
 }
 function compareCaseFolded(a, b) {
   const shorter = a.length < b.length ? a.length : b.length;
@@ -123,6 +147,28 @@ function compareSortStrings(a, b) {
   if (folded !== 0) return folded;
   return compareCodePoints(a, b);
 }
+function appendFoldedCodePoint(codePoint, out) {
+  const folded = foldOf(codePoint, singleFoldTable(), multiFoldTable());
+  if (typeof folded === "number") {
+    out.push(folded);
+    return;
+  }
+  for (const foldedCodePoint of folded) out.push(foldedCodePoint);
+}
+function appendFoldedCodePoints(text, out) {
+  const single = singleFoldTable();
+  const multi = multiFoldTable();
+  const cursor = { index: 0, pending: null, pendingIndex: 0 };
+  for (let codePoint = nextFoldedCodePoint(text, cursor, single, multi); codePoint !== EXHAUSTED; ) {
+    out.push(codePoint);
+    codePoint = nextFoldedCodePoint(text, cursor, single, multi);
+  }
+}
+function foldedCodePointCount(text) {
+  const folded = [];
+  appendFoldedCodePoints(text, folded);
+  return folded.length;
+}
 
 // src/core/ordering/constants.ts
 var SORT_VALUE_MAX_CODE_POINTS = 512;
@@ -244,4 +290,4 @@ function compareSortValues(aValues, bValues, directions) {
   return 0;
 }
 
-export { SORT_MODES, SORT_VALUE_MAX_CODE_POINTS, compareCodePoints, compareComparableKeys, compareComparableValues, compareSortValues, defaultSortMode, exceedsCodePoints, isSortMode, readSortField, sortModeOf, toComparableSortValue, toReducedSortValue, truncateSortString };
+export { SORT_MODES, SORT_VALUE_MAX_CODE_POINTS, appendFoldedCodePoint, codePointCount, compareCodePoints, compareComparableKeys, compareComparableValues, compareSortValues, defaultSortMode, exceedsCodePoints, foldedCodePointCount, holdsUnpairedSurrogate, isSortMode, readSortField, sortModeOf, toComparableSortValue, toReducedSortValue, truncateSortString };

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

@@ -1,6 +1,6 @@
-import { MAX_M } from './chunk-YNVIUGF5.mjs';
-import { exceedsCodePoints } from './chunk-OI42GWLR.mjs';
-import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
+import { MAX_M } from './chunk-P2ZZN32C.mjs';
+import { holdsUnpairedSurrogate, exceedsCodePoints } from './chunk-LJYTW7GT.mjs';
+import { NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
 
 // src/schema/constants.ts
 var MAX_NESTING_DEPTH = 4;
@@ -247,6 +247,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 +289,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 +299,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 +329,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 +354,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 +390,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 +452,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,8 +465,11 @@ 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`);
   }
@@ -473,6 +501,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 +568,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;
@@ -658,4 +698,4 @@ 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 };
+export { ANTIMERIDIAN_SPAN_DEGREES, DEFAULT_FUZZY_PREFIX_LENGTH, DEFAULT_LINEAR_ALPHA, DEFAULT_MAX_PER_GROUP, DEFAULT_PAGE_SIZE, DEFAULT_RANK_CONSTANT, DEG_TO_RAD, EARTH_RADIUS_METERS, FULL_TURN_DEGREES, LOCATION_CODE_BITS_PER_AXIS, MAX_COVERING_CELLS, MAX_CURSOR_ANCHOR_CODE_POINTS, MAX_CURSOR_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_TOLERANCE, MIN_LINEAR_ALPHA, MIN_PATTERN_VALUE_LIMIT, MIN_POLYGON_POINTS, MIN_RANK_CONSTANT, PREFIX_MAX_EXPANSIONS, PROTOTYPE_POLLUTION_KEYS, RADIUS_BOX_MARGIN_RADIANS, RADIUS_BOX_MARGIN_RATIO, RESULT_WINDOW, VECTOR_PATTERN, VINCENTY_CONVERGENCE_THRESHOLD, VINCENTY_MAX_ITERATIONS, extractVectorFieldsFromSchema, flattenSchema, isGeopointOrVectorType, isLatitude, isListBase, isLongitude, isQuantizationMode, isSingleStringFieldType, isStorageMode, isStringValuedBase, isWordIndexedBase, isWordIndexedFieldType, parsedTypeOf, requireValidFieldTypes, schemaFieldsOf, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion, validateVectorStorage, withSortableOption };

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

@@ -1,4 +1,4 @@
-import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
+import { NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
 import { existsSync } from 'fs';
 import { createRequire } from 'module';
 import { join, dirname } from 'path';