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

package/dist/{chunk-3HQPUCCT.mjs → chunk-XW25X6AU.mjs}

@@ -1,55 +1,6 @@
-import { MATCHER_STATE_BUDGET_BYTES, bitsetHas, bitsetSet, PATTERN_RUN_CODE_POINTS, MATCHER_SIMULATION_BYTES_PER_POSITION, MATCHER_STATE_OVERHEAD_BYTES, MATCHER_CODE_POINT_BYTES } from './chunk-ZKRV5M2P.mjs';
-
-// src/core/pattern-index/matcher-budget.ts
-var POSITIONS_PER_WORD = 32;
-function positionWords(positions) {
-  return Math.max(1, Math.ceil(positions / POSITIONS_PER_WORD));
-}
-function automatonBytes(positions) {
-  return 2 * positionWords(positions) * Uint32Array.BYTES_PER_ELEMENT + positions * MATCHER_CODE_POINT_BYTES;
-}
-function smallestMatcherBytes(positions) {
-  return automatonBytes(positions) + positions * MATCHER_SIMULATION_BYTES_PER_POSITION + MATCHER_STATE_OVERHEAD_BYTES + positions * Uint32Array.BYTES_PER_ELEMENT;
-}
-function widestPatternSplit(positions) {
-  return Math.max(1, Math.floor(MATCHER_STATE_BUDGET_BYTES / smallestMatcherBytes(positions)));
-}
-
-// src/pattern/automaton.ts
-function setPosition(words, position) {
-  words[position >>> 5] |= 1 << (position & 31);
-}
-function hasPosition(words, position) {
-  return (words[position >>> 5] & 1 << (position & 31)) !== 0;
-}
-function literalAutomaton(codePoints, anchoredStart, anchoredEnd) {
-  const size = codePoints.length;
-  const words = positionWords(size);
-  const first = new Uint32Array(words);
-  const last = new Uint32Array(words);
-  if (size > 0) {
-    setPosition(first, 0);
-    setPosition(last, size - 1);
-  }
-  return {
-    size,
-    words,
-    first,
-    last,
-    nullable: size === 0,
-    anchoredStart,
-    anchoredEnd,
-    bytes: automatonBytes(size),
-    accepts: (position, codePoint) => codePoints[position] === codePoint,
-    followerCount: (position) => position + 1 < size ? 1 : 0,
-    follower: (position) => position + 1
-  };
-}
+import { bitsetHas, bitsetSet, PATTERN_RUN_CODE_POINTS } from './chunk-ZKRV5M2P.mjs';
 
 // src/pattern/constants.ts
-var MATCHER_TRANSITION_BYTES = 48;
-var MATCHER_KEY_CHARACTER_BYTES = 2;
-var MATCHER_MIN_CODE_POINTS_PER_STATE = 10;
 var SHORTLIST_RUN_LOOKUPS = 16;
 var SHORTLIST_INTERSECT_RATIO = 8;
 var RUN_LIST_INITIAL_CAPACITY = 4;
@@ -57,205 +8,86 @@ var RUN_LIST_COMPACTION_FRACTION = 0.5;
 var RUN_ENTRY_OVERHEAD_BYTES = 140;
 var DOCUMENT_ENTRY_BYTES = 24;
 
-// src/pattern/position-simulation.ts
-var LAST_STAMP = 4294967295;
-var PositionSimulation = class {
-  constructor(automaton) {
-    this.automaton = automaton;
-    this.active = new Uint32Array(automaton.size);
-    this.following = new Uint32Array(automaton.size);
-    this.marks = new Uint32Array(automaton.size);
-    const first = [];
-    for (let position = 0; position < automaton.size; position++) {
-      if (hasPosition(automaton.first, position)) first.push(position);
-    }
-    this.first = Uint32Array.from(first);
-  }
+// src/pattern/literal-matcher.ts
+function bordersOf(codePoints) {
+  const length = codePoints.length;
+  const borders = new Uint32Array(length + 1);
+  let border = 0;
+  for (let at = 1; at < length; at++) {
+    while (border > 0 && codePoints[at] !== codePoints[border]) border = borders[border];
+    if (codePoints[at] === codePoints[border]) border++;
+    borders[at + 1] = border;
+  }
+  return borders;
+}
+function reachablePositionsOf(borders, length) {
+  const reachable = new Uint32Array(length + 1);
+  for (let prefix = 1; prefix <= length; prefix++) {
+    reachable[prefix] = (prefix < length ? 1 : 0) + reachable[borders[prefix]];
+  }
+  return reachable;
+}
+var LiteralMatcher = class {
+  constructor(codePoints, anchoredStart, anchoredEnd) {
+    this.codePoints = codePoints;
+    this.anchoredStart = anchoredStart;
+    this.anchoredEnd = anchoredEnd;
+    this.borders = bordersOf(codePoints);
+    this.reachable = reachablePositionsOf(this.borders, codePoints.length);
+  }
+  borders;
+  reachable;
+  prefix = 0;
+  alive = true;
   accepting = false;
-  active;
-  following;
-  marks;
-  first;
-  activeCount = 0;
-  stamp = 0;
-  get steps() {
-    return this.activeCount;
-  }
-  get bytes() {
-    return this.automaton.size * MATCHER_SIMULATION_BYTES_PER_POSITION;
-  }
-  reset() {
-    this.active.set(this.first);
-    this.activeCount = this.first.length;
-    this.accepting = this.automaton.nullable;
-  }
-  get firstPositions() {
-    return this.first;
-  }
-  load(active, accepting) {
-    this.active.set(active);
-    this.activeCount = active.length;
-    this.accepting = accepting;
-  }
-  sortedActive() {
-    return this.active.slice(0, this.activeCount).sort();
-  }
-  advance(codePoint) {
-    const { automaton, marks } = this;
-    const following = this.following;
-    const stamp = this.nextStamp();
-    let count = 0;
-    let accepting = false;
-    for (let at = 0; at < this.activeCount; at++) {
-      const position = this.active[at];
-      if (!automaton.accepts(position, codePoint)) continue;
-      if (hasPosition(automaton.last, position)) accepting = true;
-      const followers = automaton.followerCount(position);
-      for (let index = 0; index < followers; index++) {
-        const follower = automaton.follower(position, index);
-        if (marks[follower] === stamp) continue;
-        marks[follower] = stamp;
-        following[count++] = follower;
-      }
-    }
-    if (!automaton.anchoredStart) {
-      for (const position of this.first) {
-        if (marks[position] === stamp) continue;
-        marks[position] = stamp;
-        following[count++] = position;
-      }
-      if (automaton.nullable) accepting = true;
-    }
-    this.following = this.active;
-    this.active = following;
-    this.activeCount = count;
-    this.accepting = accepting;
-  }
-  nextStamp() {
-    if (this.stamp === LAST_STAMP) {
-      this.marks.fill(0);
-      this.stamp = 0;
-    }
-    this.stamp++;
-    return this.stamp;
-  }
-};
-
-// src/pattern/lazy-dfa.ts
-var UNCACHED_GENERATION = -1;
-function stateKey(active, accepting) {
-  return `${active.join(",")}${accepting ? "+" : "-"}`;
-}
-function stateBytes(active, key) {
-  return MATCHER_STATE_OVERHEAD_BYTES + active.byteLength + key.length * MATCHER_KEY_CHARACTER_BYTES;
-}
-var LazyDfa = class {
-  constructor(automaton, stateLimitBytes) {
-    this.automaton = automaton;
-    this.simulation = new PositionSimulation(automaton);
-    this.cacheLimitBytes = stateLimitBytes - automaton.bytes - this.simulation.bytes;
-    this.start = this.intern(this.simulation.firstPositions, automaton.nullable);
-    this.state = this.start;
-    if (this.wantsSimulation()) this.simulate(this.start);
-  }
-  states = /* @__PURE__ */ new Map();
-  generation = 0;
-  cachedBytes = 0;
-  codePointsSinceReset = 0;
-  start;
-  state;
-  simulating = false;
   decided = null;
-  simulation;
-  cacheLimitBytes;
   begin() {
     this.decided = null;
-    if (this.simulating) this.simulation.reset();
-    else this.state = this.start;
-    if (!this.automaton.anchoredEnd && this.accepting()) return this.decide(true);
+    this.prefix = 0;
+    this.alive = this.codePoints.length > 0;
+    this.accepting = this.codePoints.length === 0;
+    if (!this.anchoredEnd && this.accepting) return this.decide(true);
     return true;
   }
   feed(codePoint, tally) {
-    const steps = this.simulating ? this.simulation.steps : this.state.active.length;
-    if (steps === 0) return this.decide(!this.automaton.anchoredStart && this.automaton.nullable);
+    const steps = this.steps();
+    if (steps === 0) return this.decide(!this.anchoredStart && this.codePoints.length === 0);
     tally.add(steps);
-    if (this.simulating) {
-      this.simulation.advance(codePoint);
-    } else {
-      this.codePointsSinceReset++;
-      this.state = this.step(this.state, codePoint);
-      if (this.wantsSimulation()) this.simulate(this.state);
-    }
-    if (!this.automaton.anchoredEnd && this.accepting()) return this.decide(true);
+    if (this.anchoredStart) this.advanceAnchored(codePoint);
+    else this.advance(codePoint);
+    if (!this.anchoredEnd && this.accepting) return this.decide(true);
     return true;
   }
   matched() {
-    return this.decided ?? (this.automaton.anchoredEnd && this.accepting());
+    return this.decided ?? (this.anchoredEnd && this.accepting);
+  }
+  steps() {
+    const length = this.codePoints.length;
+    if (length === 0) return 0;
+    if (this.anchoredStart) return this.alive && this.prefix < length ? 1 : 0;
+    return 1 + this.reachable[this.prefix];
+  }
+  advanceAnchored(codePoint) {
+    if (this.codePoints[this.prefix] === codePoint) {
+      this.prefix++;
+      this.accepting = this.prefix === this.codePoints.length;
+      return;
+    }
+    this.alive = false;
+    this.accepting = false;
   }
-  accepting() {
-    return this.simulating ? this.simulation.accepting : this.state.accepting;
+  advance(codePoint) {
+    const { codePoints, borders } = this;
+    let prefix = this.prefix === codePoints.length ? borders[this.prefix] : this.prefix;
+    while (prefix > 0 && codePoints[prefix] !== codePoint) prefix = borders[prefix];
+    if (codePoints[prefix] === codePoint) prefix++;
+    this.prefix = prefix;
+    this.accepting = prefix === codePoints.length;
   }
   decide(outcome) {
     this.decided = outcome;
     return false;
   }
-  wantsSimulation() {
-    return !this.simulating && this.state.generation === UNCACHED_GENERATION;
-  }
-  simulate(from) {
-    this.dropCache();
-    this.state = this.start;
-    this.simulation.load(from.active, from.accepting);
-    this.simulating = true;
-  }
-  dropCache() {
-    for (const state of this.states.values()) state.next.clear();
-    this.start.next.clear();
-    this.state.next.clear();
-    this.states = /* @__PURE__ */ new Map();
-    this.cachedBytes = 0;
-  }
-  step(state, codePoint) {
-    const current = state.generation === this.generation;
-    if (current) {
-      const cached = state.next.get(codePoint);
-      if (cached !== void 0) return cached;
-    }
-    const { simulation } = this;
-    simulation.load(state.active, state.accepting);
-    simulation.advance(codePoint);
-    const next = this.intern(simulation.sortedActive(), simulation.accepting);
-    if (!current || state.generation !== this.generation || next.generation !== this.generation) return next;
-    if (!this.reserve(MATCHER_TRANSITION_BYTES) || state.generation !== this.generation) return next;
-    state.next.set(codePoint, next);
-    return next;
-  }
-  intern(active, accepting) {
-    const key = stateKey(active, accepting);
-    const existing = this.states.get(key);
-    if (existing !== void 0) return existing;
-    if (!this.reserve(stateBytes(active, key))) {
-      return { active, accepting, generation: UNCACHED_GENERATION, next: /* @__PURE__ */ new Map() };
-    }
-    const state = { active, accepting, generation: this.generation, next: /* @__PURE__ */ new Map() };
-    this.states.set(key, state);
-    return state;
-  }
-  reserve(bytes) {
-    if (this.cachedBytes + bytes <= this.cacheLimitBytes) {
-      this.cachedBytes += bytes;
-      return true;
-    }
-    if (this.states.size === 0 || this.codePointsSinceReset < MATCHER_MIN_CODE_POINTS_PER_STATE * this.states.size) {
-      return false;
-    }
-    this.dropCache();
-    this.codePointsSinceReset = 0;
-    this.generation++;
-    this.start = this.intern(this.start.active, this.start.accepting);
-    if (this.start.generation === UNCACHED_GENERATION) return false;
-    return this.reserve(bytes);
-  }
 };
 
 // src/pattern/text.ts
@@ -391,10 +223,7 @@ function matcherFor(request) {
   const { operator, text, caseFold, host } = request;
   const testCodePoints = [];
   appendTextCodePoints(text, caseFold, host, testCodePoints);
-  return new LazyDfa(
-    literalAutomaton(testCodePoints, ANCHORED_START.has(operator), ANCHORED_END.has(operator)),
-    request.meter.matcherStateBytes
-  );
+  return new LiteralMatcher(Uint32Array.from(testCodePoints), ANCHORED_START.has(operator), ANCHORED_END.has(operator));
 }
 function matchesText(matcher, text, caseFold, host, folded, tally) {
   if (!matcher.begin()) return matcher.matched();
@@ -782,4 +611,4 @@ var patternSearchModule = {
   matchInto: matchPattern
 };
 
-export { GrowableUint32, patternSearchModule, widestPatternSplit };
+export { GrowableUint32, patternSearchModule };

package/dist/{chunk-M6XF5HDE.mjs → chunk-Z3DQPOJQ.mjs}

@@ -1,6 +1,7 @@
-import { MAX_M } from './chunk-P2ZZN32C.mjs';
-import { holdsUnpairedSurrogate, exceedsCodePoints } from './chunk-LJYTW7GT.mjs';
-import { NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
+import { EARLIER_RELEASE_MIN_M, MIN_M, MAX_M } from './chunk-KEHK2O6P.mjs';
+import { compareCodePoints, 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)) {
@@ -239,6 +266,18 @@ function schemaFieldsOf(schema) {
   parsedSchemas.set(schema, frozen);
   return frozen;
 }
+var partialFieldsBySchema = /* @__PURE__ */ new WeakMap();
+function partialFieldsOf(schema) {
+  const cached = partialFieldsBySchema.get(schema);
+  if (cached !== void 0) return cached;
+  const paths = [];
+  for (const field of schemaFieldsOf(schema)) {
+    if (field.partial) paths.push(field.path);
+  }
+  const frozen = Object.freeze(paths.sort(compareCodePoints));
+  partialFieldsBySchema.set(schema, frozen);
+  return frozen;
+}
 function extractVectorFieldsFromSchema(schema) {
   const result = /* @__PURE__ */ new Map();
   for (const field of schemaFieldsOf(schema)) {
@@ -474,7 +513,11 @@ function walkStorable(value, path, depth, ancestors, skip) {
     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(
@@ -628,6 +671,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"]);
@@ -651,6 +759,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)) {
@@ -666,8 +781,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", {
@@ -680,22 +795,4 @@ function validateVectorPromotion(config) {
   }
 }
 
-// src/search/constants.ts
-var RESULT_WINDOW = 1e4;
-var DEFAULT_PAGE_SIZE = 10;
-var MAX_CURSOR_LENGTH = 40960;
-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 MAX_TOLERANCE = 10;
-var MAX_PREFIX_LENGTH = 1024;
-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 { 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 };
+export { ANTIMERIDIAN_SPAN_DEGREES, DEG_TO_RAD, EARTH_RADIUS_METERS, FULL_TURN_DEGREES, LOCATION_CODE_BITS_PER_AXIS, MAX_COVERING_CELLS, MAX_DOCUMENT_NESTING_DEPTH, MAX_LATITUDE_DEGREES, MAX_LONGITUDE_DEGREES, MAX_NESTING_DEPTH, MAX_PATTERN_VALUE_LIMIT, MAX_STORED_VECTOR_DIMENSION, MIN_PATTERN_VALUE_LIMIT, MIN_POLYGON_POINTS, PROTOTYPE_POLLUTION_KEYS, RADIUS_BOX_MARGIN_RADIANS, RADIUS_BOX_MARGIN_RATIO, VECTOR_PATTERN, VINCENTY_CONVERGENCE_THRESHOLD, VINCENTY_MAX_ITERATIONS, encodeDocument, extractVectorFieldsFromSchema, flattenSchema, isGeopointOrVectorType, isLatitude, isListBase, isLongitude, isQuantizationMode, isSingleStringFieldType, isStorageMode, isStringValuedBase, isWordIndexedBase, isWordIndexedFieldType, messagePackUpperBoundBytes, parsedTypeOf, partialFieldsOf, raiseEarlierReleaseGraphSetting, requireCreatableSchema, requireDocumentWithinSizeLimit, requireValidFieldTypes, schemaFieldsOf, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion, validateVectorStorage, withSortableOption };