@delali/narsil 0.2.4-next.51 → 0.2.4-next.54

package/dist/{chunk-CMVG2UEF.mjs → chunk-5T6AOR37.mjs}

@@ -1,7 +1,6 @@
-import { MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, RESULT_WINDOW, DEFAULT_PAGE_SIZE, PREFIX_MAX_EXPANSIONS, MAX_CURSOR_ANCHOR_CODE_POINTS } from './chunk-CBLS46IE.mjs';
-import { MAX_M } from './chunk-RP23PWMV.mjs';
+import { flattenSchema, SORTABLE_TEXT_FIELD_TYPE, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, RESULT_WINDOW, DEFAULT_PAGE_SIZE, PROTOTYPE_POLLUTION_KEYS, isTextFieldType, PREFIX_MAX_EXPANSIONS, MAX_CURSOR_ANCHOR_CODE_POINTS } from './chunk-L225SHNB.mjs';
 import { compareCodePoints, compareComparableKeys, toComparableSortValue, readSortField, SORT_VALUE_MAX_CODE_POINTS, compareSortValues } from './chunk-2GWVQWGA.mjs';
-import { createNarsilError, ErrorCodes, NarsilError } from './chunk-P4ELXVJQ.mjs';
+import { createNarsilError, ErrorCodes, NarsilError } from './chunk-FRQVMFY7.mjs';
 
 // src/core/tokenizer/constants.ts
 var TOKEN_CACHE_SIZE_FLOOR = 5e4;
@@ -70,7 +69,7 @@ function computeDefaultCacheSize() {
   try {
     if (typeof process !== "undefined" && typeof process.versions?.node === "string" && typeof window === "undefined") {
       const constrainedMemory = typeof process.constrainedMemory === "function" ? process.constrainedMemory() : 0;
-      if (constrainedMemory > 0) {
+      if (constrainedMemory > 0 && constrainedMemory < Number.MAX_SAFE_INTEGER) {
         const budget = constrainedMemory * CONSTRAINED_MEMORY_TOKEN_CACHE_FRACTION;
         return clampCacheSize(Math.floor(budget / TOKEN_CACHE_BYTES_PER_ENTRY));
       }
@@ -329,6 +328,10 @@ function expandNgrams(part, size, out) {
 }
 
 // src/core/tokenizer/tokenize.ts
+function producesSurfaceForms(language, options) {
+  if (!options?.collectSurfaces || options.customTokenizer) return false;
+  return (options.stem ?? true) && language.stemmer !== null;
+}
 var DEFAULT_SPLIT_PATTERN = /[^\p{L}\p{M}\p{N}_'-]+/u;
 function resolveStopWords(language, override) {
   if (!override) return language.stopWords;
@@ -359,7 +362,7 @@ function stripPossessive(token) {
   }
   return token;
 }
-function tokenize(text, language, options) {
+function visitTokens(text, language, options, visit) {
   const {
     stem = true,
     removeStopWords = true,
@@ -369,45 +372,42 @@ function tokenize(text, language, options) {
     stopWordOverride
   } = options ?? {};
   if (customTokenizer) {
-    const customResult = customTokenizer.tokenize(text);
-    const originals = customResult.map((t) => t.token);
-    return {
-      tokens: customResult,
-      originalTokens: originals
-    };
+    for (const entry of customTokenizer.tokenize(text)) visit(entry.token, entry.position, void 0, entry.token);
+    return;
   }
-  const normalized = normalizeForSplitting(text);
-  const rawParts = splitText(normalized, language);
+  const rawParts = splitText(normalizeForSplitting(text), language);
   const minLength = language.tokenizer?.minTokenLength ?? DEFAULT_MIN_TOKEN_LENGTH;
   const effectiveDiacritics = removeDiacritics || (language.tokenizer?.normalizeDiacritics ?? false);
-  const stemsTokens = stem && language.stemmer !== null;
-  const stopWords = removeStopWords ? resolveStopWords(language, stopWordOverride) : /* @__PURE__ */ new Set();
+  const wantSurfaces = collectSurfaces && stem && language.stemmer !== null;
+  const stopWords = removeStopWords ? resolveStopWords(language, stopWordOverride) : null;
   const stripPossessives = language.tokenizer?.stripPossessive ?? false;
-  const tokens = [];
-  const originalTokens = [];
-  const surfaces = collectSurfaces && stemsTokens ? [] : void 0;
-  let position = 0;
-  for (const part of rawParts) {
+  for (let position = 0; position < rawParts.length; position++) {
+    const part = rawParts[position];
     const candidate = stripPossessives ? stripPossessive(part) : part;
-    if (candidate.length < minLength) {
-      position++;
-      continue;
-    }
-    if (stopWords.has(candidate)) {
-      position++;
-      continue;
-    }
+    if (candidate.length < minLength || stopWords?.has(candidate)) continue;
     const processed = transformToken(candidate, language, stem, effectiveDiacritics);
-    if (processed.length > 0) {
-      tokens.push({ token: processed, position });
-      originalTokens.push(part);
-      if (surfaces) {
-        const surface = effectiveDiacritics ? transformToken(candidate, language, false, true) : candidate;
-        surfaces.push(surface === processed ? void 0 : surface);
-      }
+    if (processed.length === 0) continue;
+    if (!wantSurfaces) {
+      visit(processed, position, void 0, part);
+      continue;
     }
-    position++;
+    const surface = effectiveDiacritics ? transformToken(candidate, language, false, true) : candidate;
+    visit(processed, position, surface === processed ? void 0 : surface, part);
+  }
+}
+function tokenize(text, language, options) {
+  if (options?.customTokenizer) {
+    const customResult = options.customTokenizer.tokenize(text);
+    return { tokens: customResult, originalTokens: customResult.map((entry) => entry.token) };
   }
+  const tokens = [];
+  const originalTokens = [];
+  const surfaces = producesSurfaceForms(language, options) ? [] : void 0;
+  visitTokens(text, language, options, (token, position, surface, original) => {
+    tokens.push({ token, position });
+    originalTokens.push(original);
+    surfaces?.push(surface);
+  });
   return { tokens, originalTokens, surfaces };
 }
 function* tokenizeIterator(text, language, options) {
@@ -458,487 +458,6 @@ function* tokenizeIterator(text, language, options) {
   }
 }
 
-// src/schema/constants.ts
-var MAX_NESTING_DEPTH = 4;
-var MAX_DOCUMENT_NESTING_DEPTH = 32;
-
-// src/schema/validator/shared.ts
-var SORTABLE_TEXT_FIELD_TYPE = "string:sortable";
-var SCALAR_FIELD_TYPES = /* @__PURE__ */ new Set([
-  "string",
-  SORTABLE_TEXT_FIELD_TYPE,
-  "number",
-  "boolean",
-  "enum",
-  "geopoint",
-  "string[]",
-  "number[]",
-  "boolean[]",
-  "enum[]"
-]);
-function isTextFieldType(fieldType) {
-  return fieldType === "string" || fieldType === SORTABLE_TEXT_FIELD_TYPE;
-}
-var VECTOR_PATTERN = /^vector\[(\d+)]$/;
-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"]);
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/schema/validator/schema.ts
-function validateSchemaFields(schema, depth, prefix) {
-  if (depth > MAX_NESTING_DEPTH) {
-    throw new NarsilError(
-      ErrorCodes.SCHEMA_DEPTH_EXCEEDED,
-      `Schema nesting exceeds the maximum depth of ${MAX_NESTING_DEPTH} at "${prefix}"`,
-      { path: prefix, maxDepth: MAX_NESTING_DEPTH }
-    );
-  }
-  for (const [field, type] of Object.entries(schema)) {
-    const path = prefix ? `${prefix}.${field}` : field;
-    if (PROTOTYPE_POLLUTION_KEYS.has(field)) {
-      throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, `Field name "${field}" is not allowed in a schema`, {
-        field,
-        path
-      });
-    }
-    if (!FIELD_NAME_PATTERN.test(field)) {
-      throw new NarsilError(
-        ErrorCodes.SCHEMA_INVALID_TYPE,
-        `Field name "${field}" contains characters that are not allowed; use letters, digits, and underscores only`,
-        { field, path }
-      );
-    }
-    if (depth === 1 && RESERVED_ROOT_FIELDS.has(field)) {
-      throw new NarsilError(
-        ErrorCodes.SCHEMA_INVALID_TYPE,
-        `Field "${field}" is reserved and cannot be defined in a schema`,
-        { field, path }
-      );
-    }
-    if (isPlainObject(type)) {
-      validateSchemaFields(type, depth + 1, path);
-      continue;
-    }
-    if (typeof type !== "string") {
-      throw new NarsilError(
-        ErrorCodes.SCHEMA_INVALID_TYPE,
-        `Field "${path}" has an invalid type definition: ${String(type)}`,
-        {
-          field: path,
-          type: String(type)
-        }
-      );
-    }
-    if (SCALAR_FIELD_TYPES.has(type)) continue;
-    const vectorMatch = VECTOR_PATTERN.exec(type);
-    if (vectorMatch) {
-      const dimension = Number.parseInt(vectorMatch[1], 10);
-      if (dimension <= 0) {
-        throw new NarsilError(
-          ErrorCodes.SCHEMA_INVALID_VECTOR_DIMENSION,
-          `Vector field "${path}" must have a positive dimension, got ${dimension}`,
-          { field: path, dimension }
-        );
-      }
-      continue;
-    }
-    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, `Field "${path}" has an unsupported type: "${type}"`, {
-      field: path,
-      type
-    });
-  }
-}
-function validateSchema(schema) {
-  if (!isPlainObject(schema)) {
-    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must be a plain object", {
-      received: typeof schema
-    });
-  }
-  if (Object.keys(schema).length === 0) {
-    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must define at least one field");
-  }
-  validateSchemaFields(schema, 1, "");
-}
-function flattenRecursive(schema, prefix, result) {
-  for (const [field, type] of Object.entries(schema)) {
-    const path = prefix ? `${prefix}.${field}` : field;
-    if (isPlainObject(type)) {
-      flattenRecursive(type, path, result);
-    } else {
-      result[path] = type;
-    }
-  }
-}
-function flattenSchema(schema) {
-  const result = {};
-  flattenRecursive(schema, "", result);
-  return result;
-}
-function extractVectorFieldsFromSchema(schema) {
-  const flat = flattenSchema(schema);
-  const result = /* @__PURE__ */ new Map();
-  for (const [fieldPath, fieldType] of Object.entries(flat)) {
-    const match = VECTOR_PATTERN.exec(fieldType);
-    if (match) {
-      result.set(fieldPath, Number.parseInt(match[1], 10));
-    }
-  }
-  return result;
-}
-
-// src/schema/validator/field-values.ts
-function validateGeopoint(path, value) {
-  if (!isPlainObject(value)) {
-    throw new NarsilError(
-      ErrorCodes.SCHEMA_INVALID_GEOPOINT,
-      `Field "${path}" expected a geopoint object with lat and lon`,
-      {
-        field: path,
-        received: Array.isArray(value) ? "array" : typeof value
-      }
-    );
-  }
-  if (typeof value.lat !== "number" || typeof value.lon !== "number" || Number.isNaN(value.lat) || Number.isNaN(value.lon)) {
-    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_GEOPOINT, `Field "${path}" geopoint requires numeric lat and lon`, {
-      field: path,
-      lat: Number.isNaN(value.lat) ? "NaN" : typeof value.lat,
-      lon: Number.isNaN(value.lon) ? "NaN" : typeof value.lon
-    });
-  }
-  if (value.lat < -90 || value.lat > 90) {
-    throw new NarsilError(
-      ErrorCodes.SCHEMA_INVALID_GEOPOINT,
-      `Field "${path}" geopoint lat must be between -90 and 90`,
-      {
-        field: path,
-        lat: value.lat
-      }
-    );
-  }
-  if (value.lon < -180 || value.lon > 180) {
-    throw new NarsilError(
-      ErrorCodes.SCHEMA_INVALID_GEOPOINT,
-      `Field "${path}" geopoint lon must be between -180 and 180`,
-      {
-        field: path,
-        lon: value.lon
-      }
-    );
-  }
-}
-function validateVector(path, value, expectedDimension) {
-  const isArray = Array.isArray(value);
-  const isFloat32 = value instanceof Float32Array;
-  if (!isArray && !isFloat32) {
-    throw new NarsilError(
-      ErrorCodes.DOC_VALIDATION_FAILED,
-      `Field "${path}" expected a vector (Array or Float32Array)`,
-      { field: path, received: typeof value }
-    );
-  }
-  const arr = value;
-  if (arr.length !== expectedDimension) {
-    throw new NarsilError(
-      ErrorCodes.DOC_VALIDATION_FAILED,
-      `Field "${path}" expected vector of dimension ${expectedDimension}, got ${arr.length}`,
-      { field: path, expected: expectedDimension, received: arr.length }
-    );
-  }
-  for (let i = 0; i < arr.length; i++) {
-    if (typeof arr[i] !== "number" || Number.isNaN(arr[i])) {
-      throw new NarsilError(
-        ErrorCodes.DOC_VALIDATION_FAILED,
-        `Field "${path}" vector element at index ${i} is not a valid number`,
-        { field: path, index: i, value: arr[i] }
-      );
-    }
-  }
-}
-function validateTypedArray(path, value, elementType) {
-  if (!Array.isArray(value)) {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected an array`, {
-      field: path,
-      received: typeof value
-    });
-  }
-  for (let i = 0; i < value.length; i++) {
-    const el = value[i];
-    if (typeof el !== elementType) {
-      throw new NarsilError(
-        ErrorCodes.DOC_VALIDATION_FAILED,
-        `Field "${path}" array element at index ${i} expected ${elementType}, got ${typeof el}`,
-        { 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
-      });
-    }
-  }
-}
-function validateFieldValue(path, value, type) {
-  switch (type) {
-    case "string":
-    case SORTABLE_TEXT_FIELD_TYPE:
-      if (typeof value !== "string") {
-        throw new NarsilError(
-          ErrorCodes.DOC_VALIDATION_FAILED,
-          `Field "${path}" expected string, got ${typeof value}`,
-          {
-            field: path,
-            expected: "string",
-            received: typeof value
-          }
-        );
-      }
-      return;
-    case "number":
-      if (typeof value !== "number" || Number.isNaN(value)) {
-        throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected a valid number`, {
-          field: path,
-          expected: "number",
-          received: Number.isNaN(value) ? "NaN" : typeof value
-        });
-      }
-      return;
-    case "boolean":
-      if (typeof value !== "boolean") {
-        throw new NarsilError(
-          ErrorCodes.DOC_VALIDATION_FAILED,
-          `Field "${path}" expected boolean, got ${typeof value}`,
-          {
-            field: path,
-            expected: "boolean",
-            received: typeof value
-          }
-        );
-      }
-      return;
-    case "enum":
-      if (typeof value !== "string") {
-        throw new NarsilError(
-          ErrorCodes.DOC_VALIDATION_FAILED,
-          `Field "${path}" expected enum (string), got ${typeof value}`,
-          {
-            field: path,
-            expected: "enum",
-            received: typeof value
-          }
-        );
-      }
-      return;
-    case "geopoint":
-      validateGeopoint(path, value);
-      return;
-    case "string[]":
-      validateTypedArray(path, value, "string");
-      return;
-    case "number[]":
-      validateTypedArray(path, value, "number");
-      return;
-    case "boolean[]":
-      validateTypedArray(path, value, "boolean");
-      return;
-    case "enum[]":
-      validateTypedArray(path, value, "string");
-      return;
-    default: {
-      const vectorMatch = VECTOR_PATTERN.exec(type);
-      if (vectorMatch) {
-        validateVector(path, value, Number.parseInt(vectorMatch[1], 10));
-      }
-    }
-  }
-}
-
-// src/schema/validator/storable.ts
-var RESERVED_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function reject(path, reason) {
-  throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path === "" ? "(document)" : path}" ${reason}`, {
-    field: path
-  });
-}
-function isPlainObject2(value) {
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-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 === "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;
-  const isArray = Array.isArray(container);
-  if (!isArray && !isPlainObject2(container)) {
-    reject(
-      path,
-      "holds a value that does not survive storage; use plain objects, arrays, strings, numbers, booleans, dates, or Uint8Array bytes"
-    );
-  }
-  if (depth >= MAX_DOCUMENT_NESTING_DEPTH) {
-    reject(path, `nests deeper than ${MAX_DOCUMENT_NESTING_DEPTH} levels`);
-  }
-  if (ancestors.has(container)) {
-    reject(path, "refers back to one of its own ancestors");
-  }
-  ancestors.add(container);
-  if (isArray) {
-    const items = container;
-    for (let i = 0; i < items.length; i++) {
-      walkStorable(items[i], `${path}[${i}]`, depth + 1, ancestors, skip);
-    }
-  } else {
-    const record = container;
-    for (const key of Object.keys(record)) {
-      const keyPath = path === "" ? key : `${path}.${key}`;
-      if (RESERVED_OBJECT_KEYS.has(key)) {
-        reject(keyPath, "uses a reserved object key");
-      }
-      if (skip.has(keyPath)) continue;
-      walkStorable(record[key], keyPath, depth + 1, ancestors, skip);
-    }
-  }
-  ancestors.delete(container);
-}
-function assertStorableDocument(document, skipFieldPaths) {
-  walkStorable(document, "", 0, /* @__PURE__ */ new Set(), skipFieldPaths ?? /* @__PURE__ */ new Set());
-}
-
-// src/schema/validator/document.ts
-var vectorPathCache = /* @__PURE__ */ new WeakMap();
-function vectorFieldPaths(schema) {
-  let paths = vectorPathCache.get(schema);
-  if (paths !== void 0) return paths;
-  paths = /* @__PURE__ */ new Set();
-  const collect = (level, prefix) => {
-    for (const [field, type] of Object.entries(level)) {
-      const path = prefix === "" ? field : `${prefix}.${field}`;
-      if (typeof type === "string" && VECTOR_PATTERN.test(type)) {
-        paths?.add(path);
-      } else if (isPlainObject(type)) {
-        collect(type, path);
-      }
-    }
-  };
-  collect(schema, "");
-  vectorPathCache.set(schema, paths);
-  return paths;
-}
-function validateDocumentFields(doc, schema, prefix) {
-  for (const [field, type] of Object.entries(schema)) {
-    const path = prefix ? `${prefix}.${field}` : field;
-    const value = doc[field];
-    if (value === void 0 || value === null) continue;
-    if (isPlainObject(type)) {
-      if (!isPlainObject(value)) {
-        throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected an object`, {
-          field: path,
-          received: Array.isArray(value) ? "array" : typeof value
-        });
-      }
-      validateDocumentFields(value, type, path);
-      continue;
-    }
-    validateFieldValue(path, value, type);
-  }
-}
-function validateDocument(document, schema) {
-  if (!isPlainObject(document)) {
-    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Document must be a plain object", {
-      received: typeof document
-    });
-  }
-  assertStorableDocument(document, vectorFieldPaths(schema));
-  validateDocumentFields(document, schema, "");
-}
-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)) {
-      extras.push(path);
-      continue;
-    }
-    const schemaType = schema[key];
-    if (isPlainObject(schemaType) && isPlainObject(doc[key])) {
-      collectExtraFields(doc[key], schemaType, path, extras);
-    }
-  }
-}
-function validateDocumentStrict(document, schema) {
-  const extras = [];
-  collectExtraFields(document, schema, "", extras);
-  if (extras.length > 0) {
-    throw new NarsilError(
-      ErrorCodes.DOC_VALIDATION_FAILED,
-      `Document contains fields not defined in schema: ${extras.join(", ")}`,
-      { extraFields: extras }
-    );
-  }
-}
-function resolveNestedValue(document, path) {
-  if (!path.includes(".")) return document[path];
-  const segments = path.split(".");
-  let current = document;
-  for (const segment of segments) {
-    if (current === null || current === void 0 || typeof current !== "object") return void 0;
-    current = current[segment];
-  }
-  return current;
-}
-function validateRequiredFields(document, required) {
-  if (required.length === 0) return;
-  for (const field of required) {
-    const value = resolveNestedValue(document, field);
-    if (value === void 0 || value === null) {
-      throw new NarsilError(ErrorCodes.DOC_MISSING_REQUIRED_FIELD, `Document is missing required field "${field}"`, {
-        field
-      });
-    }
-  }
-}
-
-// src/schema/validator/vector-promotion.ts
-function fail(message, details) {
-  throw new NarsilError(ErrorCodes.CONFIG_INVALID, message, details);
-}
-function isPositiveInteger(value) {
-  return Number.isInteger(value) && value >= 1;
-}
-function validateVectorPromotion(config) {
-  if (config === void 0) return;
-  if (config.threshold !== void 0 && !isPositiveInteger(config.threshold)) {
-    fail("vectorPromotion.threshold must be a positive integer", { threshold: config.threshold });
-  }
-  const quantization = config.quantization;
-  if (quantization !== void 0 && quantization !== "sq8" && quantization !== "none") {
-    fail("vectorPromotion.quantization must be 'sq8' or 'none'", { quantization });
-  }
-  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.efConstruction !== void 0 && !isPositiveInteger(hnsw.efConstruction)) {
-    fail("vectorPromotion.hnswConfig.efConstruction must be a positive integer", {
-      efConstruction: hnsw.efConstruction
-    });
-  }
-  const metric = hnsw.metric;
-  if (metric !== void 0 && metric !== "cosine" && metric !== "dotProduct" && metric !== "euclidean") {
-    fail("vectorPromotion.hnswConfig.metric must be 'cosine', 'dotProduct', or 'euclidean'", { metric });
-  }
-}
-
 // src/partitioning/distributed-scoring.ts
 function analysedQueryTokens(term, language, analysis) {
   const { tokens } = tokenize(term, language, {
@@ -2035,4 +1554,23 @@ function fnv1a(input) {
   return fnv1aBytes(encoder.encode(input));
 }
 
-export { MAX_NESTING_DEPTH, VECTOR_PATTERN, applyPagination, applyProjection, applySorting, bitsetAnd, bitsetFromSet, bitsetHas, bitsetNot, bitsetOr, bitsetSet, boundedLevenshtein, clampRowCount, clearNormalizationCache, cloneProjected, collectQueryTermStats, configureNormalizationCache, countsWithoutScores, createBitSet, decodePageCursor, encodePageCursor, extractVectorFieldsFromSchema, fanOutMatchCount, fanOutQuery, flattenSchema, fnv1a, fnv1aBytes, fulltextMatches, getNormalizationCacheSize, isTextFieldType, kWayMerge, mergeFacets, mergePartitionStats, normalizeSort, partitionsIn, projectionKeepsField, pruneStatsToQueryTerms, readSortValues, requireMatchingCursor, requireSortableFields, requireWithinResultWindow, resetNormalizationCache, resolveProjection, sanitizeGlobalStats, sortSignatureOf, tokenize, tokenizeIterator, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion };
+// src/partitioning/manager/nested-values.ts
+function setNestedValue(obj, path, value) {
+  if (!path.includes(".")) {
+    obj[path] = value;
+    return;
+  }
+  const segments = path.split(".");
+  let current = obj;
+  for (let i = 0; i < segments.length - 1; i++) {
+    let next = current[segments[i]];
+    if (next === null || next === void 0 || typeof next !== "object") {
+      next = {};
+      current[segments[i]] = next;
+    }
+    current = next;
+  }
+  current[segments[segments.length - 1]] = value;
+}
+
+export { applyPagination, applyProjection, applySorting, bitsetAnd, bitsetFromSet, bitsetHas, bitsetNot, bitsetOr, bitsetSet, boundedLevenshtein, clampRowCount, clearNormalizationCache, cloneProjected, collectQueryTermStats, configureNormalizationCache, countsWithoutScores, createBitSet, decodePageCursor, encodePageCursor, fanOutMatchCount, fanOutQuery, fnv1a, fnv1aBytes, fulltextMatches, getNormalizationCacheSize, kWayMerge, mergeFacets, mergePartitionStats, normalizeSort, partitionsIn, projectionKeepsField, pruneStatsToQueryTerms, readSortValues, requireMatchingCursor, requireSortableFields, requireWithinResultWindow, resetNormalizationCache, resolveProjection, sanitizeGlobalStats, setNestedValue, sortSignatureOf, tokenize, tokenizeIterator, visitTokens };