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

package/dist/{chunk-LMO5TJUS.mjs → chunk-QR4OKRVY.mjs}

@@ -1,6 +1,7 @@
-import { isWordIndexedBase, flattenSchema, parsedTypeOf, isStringValuedBase, withSortableOption, isGeopointOrVectorType, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, MAX_CURSOR_ANCHOR_CODE_POINTS, RESULT_WINDOW, DEFAULT_FUZZY_PREFIX_LENGTH, DEFAULT_PAGE_SIZE, PROTOTYPE_POLLUTION_KEYS, isWordIndexedFieldType, PREFIX_MAX_EXPANSIONS } from './chunk-653BNMAF.mjs';
-import { compareCodePoints, sortModeOf, defaultSortMode, SORT_VALUE_MAX_CODE_POINTS, toReducedSortValue, readSortField, compareComparableKeys, toComparableSortValue, exceedsCodePoints, isSortMode, SORT_MODES, compareSortValues } from './chunk-OI42GWLR.mjs';
-import { createNarsilError, ErrorCodes, NarsilError } from './chunk-USKFU7J5.mjs';
+import { isWordIndexedBase, flattenSchema, MAX_LATITUDE_DEGREES, MAX_LONGITUDE_DEGREES, MIN_POLYGON_POINTS, parsedTypeOf, isStringValuedBase, withSortableOption, isGeopointOrVectorType, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, MAX_CURSOR_ANCHOR_CODE_POINTS, RESULT_WINDOW, DEFAULT_FUZZY_PREFIX_LENGTH, EARTH_RADIUS_METERS, RADIUS_BOX_MARGIN_RATIO, RADIUS_BOX_MARGIN_RADIANS, FULL_TURN_DEGREES, ANTIMERIDIAN_SPAN_DEGREES, DEFAULT_PAGE_SIZE, PROTOTYPE_POLLUTION_KEYS, DEG_TO_RAD, LOCATION_CODE_BITS_PER_AXIS, isLatitude, isLongitude, isWordIndexedFieldType, PREFIX_MAX_EXPANSIONS, MAX_COVERING_CELLS } from './chunk-M6XF5HDE.mjs';
+import { DEFAULT_PATTERN_WORK_CAP, PATTERN_TEST_OPERATORS, bitsetIsEmpty, MAX_PATTERN_TEXT_CODE_POINTS, MAX_PATTERN_POSITIONS, createBitSet, bitsetSet, PATTERN_WORK_FLUSH_UNITS, MATCHER_STATE_BUDGET_BYTES } from './chunk-ZKRV5M2P.mjs';
+import { compareCodePoints, sortModeOf, defaultSortMode, SORT_VALUE_MAX_CODE_POINTS, toReducedSortValue, readSortField, compareComparableKeys, toComparableSortValue, exceedsCodePoints, holdsUnpairedSurrogate, isSortMode, SORT_MODES, compareSortValues, foldedCodePointCount } from './chunk-LJYTW7GT.mjs';
+import { createNarsilError, ErrorCodes, NarsilError } from './chunk-RV77FR2F.mjs';
 
 // src/core/tokenizer/constants.ts
 var TOKEN_CACHE_SIZE_FLOOR = 5e4;
@@ -458,6 +459,100 @@ function* tokenizeIterator(text, language, options) {
   }
 }
 
+// src/core/pattern-index/work-meter.ts
+var COUNTER_BYTES = 8;
+function capExceeded(cap) {
+  return new NarsilError(
+    ErrorCodes.SEARCH_WORK_CAP_EXCEEDED,
+    `The engine stopped this search before it checked every candidate, because the work on its pattern tests passed the cap of ${cap} units. Narrow the tests, or raise the patternWorkCap engine setting`,
+    { cap }
+  );
+}
+function localMeter(cap, spent, matcherStateBytes, flushUnits) {
+  let total = spent;
+  let sharedCount = null;
+  const spentSoFar = () => sharedCount === null ? total : Number(Atomics.load(sharedCount, 0));
+  const meter = {
+    cap,
+    matcherStateBytes,
+    flushUnits,
+    add(units) {
+      if (units <= 0) return;
+      if (sharedCount === null) total += units;
+      else total = Number(Atomics.add(sharedCount, 0, BigInt(units))) + units;
+      if (total > cap) throw capExceeded(cap);
+    },
+    remaining() {
+      return cap - spentSoFar();
+    },
+    fork(workerCount) {
+      const copies = Math.max(1, workerCount);
+      const seed = spentSoFar();
+      let counter = null;
+      if (typeof SharedArrayBuffer === "function") {
+        counter = new SharedArrayBuffer(COUNTER_BYTES);
+        new BigInt64Array(counter)[0] = BigInt(seed);
+      }
+      const shared = {
+        cap,
+        spent: seed,
+        counter,
+        matcherStateBytes: Math.floor(matcherStateBytes / copies),
+        flushUnits: Math.max(1, Math.floor(flushUnits / copies))
+      };
+      return {
+        shared,
+        settle(reportedUnits) {
+          if (counter === null) {
+            meter.add(reportedUnits);
+            return;
+          }
+          const unitsSinceFork = spentSoFar() - seed;
+          const view = new BigInt64Array(counter);
+          if (unitsSinceFork > 0) Atomics.add(view, 0, BigInt(unitsSinceFork));
+          sharedCount = view;
+          total = spentSoFar();
+          if (total > cap) throw capExceeded(cap);
+        }
+      };
+    }
+  };
+  return meter;
+}
+function createPatternWorkMeter(cap = DEFAULT_PATTERN_WORK_CAP) {
+  return localMeter(cap, 0, MATCHER_STATE_BUDGET_BYTES, PATTERN_WORK_FLUSH_UNITS);
+}
+function sharedMeter(work, counter) {
+  const view = new BigInt64Array(counter);
+  return {
+    matcherStateBytes: work.matcherStateBytes,
+    flushUnits: work.flushUnits,
+    add(units) {
+      if (units <= 0) return;
+      const total = Number(Atomics.add(view, 0, BigInt(units))) + units;
+      if (total > work.cap) throw capExceeded(work.cap);
+    },
+    remaining() {
+      return work.cap - Number(Atomics.load(view, 0));
+    }
+  };
+}
+function joinPatternWorkMeter(work) {
+  const meter = work.counter === null ? localMeter(work.cap, work.spent, work.matcherStateBytes, work.flushUnits) : sharedMeter(work, work.counter);
+  let spent = 0;
+  return {
+    matcherStateBytes: meter.matcherStateBytes,
+    flushUnits: meter.flushUnits,
+    add(units) {
+      if (units <= 0) return;
+      spent += units;
+      meter.add(units);
+    },
+    remaining: () => meter.remaining(),
+    spent: () => spent
+  };
+}
+
 // src/partitioning/distributed-scoring.ts
 function analysedQueryTokens(term, language, analysis) {
   const { tokens } = tokenize(term, language, {
@@ -673,67 +768,6 @@ function heapPop(heap) {
   return top;
 }
 
-// src/core/bitset.ts
-function createBitSet(capacity) {
-  return new Uint32Array(capacity + 31 >>> 5 || 1);
-}
-function bitsetSet(bs, index) {
-  const word = index >>> 5;
-  if (word < bs.length) {
-    bs[word] |= 1 << (index & 31);
-  }
-}
-function bitsetHas(bs, index) {
-  const word = index >>> 5;
-  if (word >= bs.length) return false;
-  return (bs[word] & 1 << (index & 31)) !== 0;
-}
-function bitsetAnd(a, b) {
-  const len = Math.min(a.length, b.length);
-  const result = new Uint32Array(len);
-  for (let i = 0; i < len; i++) {
-    result[i] = a[i] & b[i];
-  }
-  return result;
-}
-function bitsetOr(a, b) {
-  const longer = a.length >= b.length ? a : b;
-  const shorter = a.length >= b.length ? b : a;
-  const result = new Uint32Array(longer.length);
-  for (let i = 0; i < shorter.length; i++) {
-    result[i] = longer[i] | shorter[i];
-  }
-  for (let i = shorter.length; i < longer.length; i++) {
-    result[i] = longer[i];
-  }
-  return result;
-}
-function bitsetNot(bs, capacity) {
-  const result = new Uint32Array(bs.length);
-  const fullWords = capacity >>> 5;
-  for (let i = 0; i < fullWords; i++) {
-    result[i] = ~bs[i];
-  }
-  const remainder = capacity & 31;
-  if (remainder > 0 && fullWords < bs.length) {
-    result[fullWords] = ~bs[fullWords] & (1 << remainder) - 1;
-  }
-  return result;
-}
-function bitsetIsEmpty(bs) {
-  for (let i = 0; i < bs.length; i++) {
-    if (bs[i] !== 0) return false;
-  }
-  return true;
-}
-function bitsetFromSet(set, capacity) {
-  const bs = createBitSet(capacity);
-  for (const id of set) {
-    bs[id >>> 5] |= 1 << (id & 31);
-  }
-  return bs;
-}
-
 // src/core/partition/utils.ts
 function getOrCreateFieldNameIndex(table, fieldName) {
   const existing = table.indexMap.get(fieldName);
@@ -800,13 +834,6 @@ function getFieldValueByInternalId(docStore, internalId, fieldPath) {
   if (externalId === void 0) return void 0;
   return getFieldValueForDoc(docStore, externalId, fieldPath);
 }
-function getAllInternalDocIds(docStore) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const internalId of docStore.allInternalIds()) {
-    ids.add(internalId);
-  }
-  return ids;
-}
 
 // src/core/partition/facets.ts
 var UNDECLARED_FIELD_TYPE = "";
@@ -1084,13 +1111,205 @@ function decodeCursorText(encoded) {
   return new TextDecoder().decode(bytes);
 }
 
-// src/geo/constants.ts
-var DEG_TO_RAD = Math.PI / 180;
-var MIN_POLYGON_POINTS = 3;
-var ANTIMERIDIAN_SPAN_DEGREES = 180;
-var FULL_TURN_DEGREES = 360;
-var VINCENTY_MAX_ITERATIONS = 200;
-var VINCENTY_CONVERGENCE_THRESHOLD = 1e-12;
+// src/filters/constants.ts
+var MAX_FILTER_DEPTH = 30;
+var MAX_FILTER_TESTS = 1024;
+var MAX_FILTER_ARRAY_SIZE = 65536;
+var GEO_UNIT_METRES = { km: 1e3, mi: 1609.344, m: 1 };
+
+// src/filters/operands/checks.ts
+function operandKindOf(type) {
+  if (type === void 0) return void 0;
+  if (type === "number" || type === "number[]") return "number";
+  if (type === "boolean" || type === "boolean[]") return "boolean";
+  if (type === "geopoint") return "geopoint";
+  if (type.startsWith("vector[")) return "vector";
+  return "text";
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function kindOfValue(value) {
+  if (isFiniteNumber(value)) return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "string") return "text";
+  return void 0;
+}
+function isObjectRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function invalid(message, fieldPath, operator) {
+  throw new NarsilError(ErrorCodes.SEARCH_INVALID_FILTER, message, { fieldPath, operator });
+}
+function requireFieldKind(fieldPath, operator, type, accepted) {
+  const kind = operandKindOf(type);
+  if (kind === void 0 || accepted.includes(kind)) return;
+  invalid(
+    `The engine applies "${operator}" to ${accepted.join(" or ")} fields alone, and the schema declares field "${fieldPath}" as "${type}"`,
+    fieldPath,
+    operator
+  );
+}
+function requireTextRangeField(fieldPath, operator, type) {
+  const parsed = parsedTypeOf(type);
+  if (parsed?.sortable && (parsed.base === "string" || parsed.base === "verbatim")) return;
+  const declared = type === void 0 ? `the schema has no field "${fieldPath}"` : `field "${fieldPath}" has type "${type}"`;
+  invalid(
+    `The engine applies "${operator}" with a text bound to a "string" or "verbatim" field whose type includes "sortable", but ${declared}`,
+    fieldPath,
+    operator
+  );
+}
+function requireListLength(fieldPath, operator, values) {
+  if (values.length <= MAX_FILTER_ARRAY_SIZE) return;
+  invalid(
+    `"${operator}" on field "${fieldPath}" holds ${values.length} values, while a filter list holds at most ${MAX_FILTER_ARRAY_SIZE}`,
+    fieldPath,
+    operator
+  );
+}
+
+// src/geo/cells.ts
+var AXIS_CELLS = 2 ** LOCATION_CODE_BITS_PER_AXIS;
+function axisCell(value, lowest, span) {
+  const cell = Math.floor((value - lowest) / span * AXIS_CELLS);
+  if (!(cell > 0)) return 0;
+  return cell >= AXIS_CELLS ? AXIS_CELLS - 1 : cell;
+}
+function latitudeCell(lat) {
+  return axisCell(lat, -MAX_LATITUDE_DEGREES, 2 * MAX_LATITUDE_DEGREES);
+}
+function longitudeCell(lon) {
+  return axisCell(lon, -MAX_LONGITUDE_DEGREES, FULL_TURN_DEGREES);
+}
+function interleave(row, column, bits) {
+  let code = 0;
+  for (let bit = bits - 1; bit >= 0; bit--) code = code * 4 + (row >>> bit & 1) * 2 + (column >>> bit & 1);
+  return code;
+}
+function locationCode(lat, lon) {
+  return interleave(latitudeCell(lat), longitudeCell(lon), LOCATION_CODE_BITS_PER_AXIS);
+}
+function appendBoxRanges(box, out) {
+  const south = latitudeCell(box.south);
+  const north = latitudeCell(box.north);
+  const west = longitudeCell(box.west);
+  const east = longitudeCell(box.east);
+  let level = LOCATION_CODE_BITS_PER_AXIS;
+  while (level > 0) {
+    const shift2 = LOCATION_CODE_BITS_PER_AXIS - level;
+    const rows = (north >>> shift2) - (south >>> shift2) + 1;
+    const columns = (east >>> shift2) - (west >>> shift2) + 1;
+    if (rows * columns <= MAX_COVERING_CELLS) break;
+    level--;
+  }
+  const shift = LOCATION_CODE_BITS_PER_AXIS - level;
+  const codesPerCell = 4 ** shift;
+  for (let row = south >>> shift; row <= north >>> shift; row++) {
+    for (let column = west >>> shift; column <= east >>> shift; column++) {
+      const from = interleave(row, column, level) * codesPerCell;
+      out.push({ from, to: from + codesPerCell });
+    }
+  }
+}
+function coveringRanges(boxes) {
+  const ranges = [];
+  for (const box of boxes) appendBoxRanges(box, ranges);
+  ranges.sort((left, right) => left.from - right.from);
+  const merged = [];
+  for (const range of ranges) {
+    const last = merged[merged.length - 1];
+    if (last !== void 0 && range.from <= last.to) {
+      if (range.to > last.to) last.to = range.to;
+    } else {
+      merged.push({ from: range.from, to: range.to });
+    }
+  }
+  return merged;
+}
+function longitudeBoxes(south, north, west, east) {
+  if (east - west >= FULL_TURN_DEGREES) {
+    return [{ south, north, west: -MAX_LONGITUDE_DEGREES, east: MAX_LONGITUDE_DEGREES }];
+  }
+  if (west < -MAX_LONGITUDE_DEGREES) {
+    return [
+      { south, north, west: west + FULL_TURN_DEGREES, east: MAX_LONGITUDE_DEGREES },
+      { south, north, west: -MAX_LONGITUDE_DEGREES, east }
+    ];
+  }
+  if (east > MAX_LONGITUDE_DEGREES) {
+    return [
+      { south, north, west, east: MAX_LONGITUDE_DEGREES },
+      { south, north, west: -MAX_LONGITUDE_DEGREES, east: east - FULL_TURN_DEGREES }
+    ];
+  }
+  return [{ south, north, west, east }];
+}
+function radiusBoxes(lat, lon, distanceMeters) {
+  const angle = distanceMeters / EARTH_RADIUS_METERS * RADIUS_BOX_MARGIN_RATIO + RADIUS_BOX_MARGIN_RADIANS;
+  const angleDegrees = angle / DEG_TO_RAD;
+  const south = lat - angleDegrees;
+  const north = lat + angleDegrees;
+  if (angle >= Math.PI || south <= -MAX_LATITUDE_DEGREES || north >= MAX_LATITUDE_DEGREES) {
+    return [
+      {
+        south: Math.max(south, -MAX_LATITUDE_DEGREES),
+        north: Math.min(north, MAX_LATITUDE_DEGREES),
+        west: -MAX_LONGITUDE_DEGREES,
+        east: MAX_LONGITUDE_DEGREES
+      }
+    ];
+  }
+  const spread = Math.asin(Math.sin(angle) / Math.cos(lat * DEG_TO_RAD)) / DEG_TO_RAD;
+  return longitudeBoxes(south, north, lon - spread, lon + spread);
+}
+
+// src/geo/edge-tree.ts
+function buildLongitudeEdgeTree(lons) {
+  const n = lons.length;
+  const edges = [];
+  for (let i = 0; i < n; i++) {
+    if (lons[i] !== lons[i === 0 ? n - 1 : i - 1]) edges.push(i);
+  }
+  const lowOf = (i) => Math.min(lons[i], lons[i === 0 ? n - 1 : i - 1]);
+  edges.sort((left, right) => lowOf(left) - lowOf(right));
+  const count = edges.length;
+  const tree = {
+    from: new Int32Array(count),
+    to: new Int32Array(count),
+    low: new Float64Array(count),
+    high: new Float64Array(count),
+    subtreeHigh: new Float64Array(count)
+  };
+  edges.forEach((i, at) => {
+    const j = i === 0 ? n - 1 : i - 1;
+    tree.from[at] = i;
+    tree.to[at] = j;
+    tree.low[at] = Math.min(lons[i], lons[j]);
+    tree.high[at] = Math.max(lons[i], lons[j]);
+  });
+  const fillSubtreeHigh = (start, end) => {
+    if (start >= end) return Number.NEGATIVE_INFINITY;
+    const mid = start + end >>> 1;
+    const highest = Math.max(tree.high[mid], fillSubtreeHigh(start, mid), fillSubtreeHigh(mid + 1, end));
+    tree.subtreeHigh[mid] = highest;
+    return highest;
+  };
+  fillSubtreeHigh(0, count);
+  return tree;
+}
+function forEachEdgeSpanning(tree, lon, visit) {
+  const walk = (start, end) => {
+    if (start >= end) return;
+    const mid = start + end >>> 1;
+    if (tree.subtreeHigh[mid] <= lon) return;
+    walk(start, mid);
+    if (tree.low[mid] > lon) return;
+    if (lon < tree.high[mid]) visit(tree.from[mid], tree.to[mid]);
+    walk(mid + 1, end);
+  };
+  walk(0, tree.from.length);
+}
 
 // src/geo/polygon.ts
 function requirePolygonRing(points) {
@@ -1103,11 +1322,18 @@ function requirePolygonRing(points) {
   }
   points.forEach((point, position) => {
     const { lat, lon } = point ?? {};
-    if (typeof lat === "number" && Number.isFinite(lat) && typeof lon === "number" && Number.isFinite(lon)) return;
+    if (typeof lat !== "number" || !Number.isFinite(lat) || typeof lon !== "number" || !Number.isFinite(lon)) {
+      throw new NarsilError(
+        ErrorCodes.SEARCH_INVALID_FILTER,
+        `A polygon point carries a finite "lat" and "lon", and the point at position ${position} does not`,
+        { position }
+      );
+    }
+    if (isLatitude(lat) && isLongitude(lon)) return;
     throw new NarsilError(
       ErrorCodes.SEARCH_INVALID_FILTER,
-      `A polygon point carries a finite "lat" and "lon", and the point at position ${position} does not`,
-      { position }
+      `A polygon point must hold a "lat" from -${MAX_LATITUDE_DEGREES} to ${MAX_LATITUDE_DEGREES} and a "lon" from -${MAX_LONGITUDE_DEGREES} to ${MAX_LONGITUDE_DEGREES}, while the point at position ${position} holds ${lat}, ${lon}`,
+      { position, lat, lon }
     );
   });
 }
@@ -1140,67 +1366,40 @@ function polygonContainment(polygon) {
     lats[i] = polygon[i].lat;
     lons[i] = unwrap ? eastward(polygon[i].lon) : polygon[i].lon;
   }
+  const edges = buildLongitudeEdgeTree(lons);
   return (lat, rawLon) => {
     const lon = unwrap ? eastward(rawLon) : rawLon;
     let inside = false;
-    for (let i = 0, j = n - 1; i < n; j = i++) {
-      const lonI = lons[i];
-      const lonJ = lons[j];
-      if (lonI > lon !== lonJ > lon) {
-        const intersectLat = lats[i] + (lats[j] - lats[i]) / (lonJ - lonI) * (lon - lonI);
-        if (lat < intersectLat) inside = !inside;
-      }
-    }
+    forEachEdgeSpanning(edges, lon, (i, j) => {
+      const intersectLat = lats[i] + (lats[j] - lats[i]) / (lons[j] - lons[i]) * (lon - lons[i]);
+      if (lat < intersectLat) inside = !inside;
+    });
     return inside;
   };
 }
-
-// src/filters/constants.ts
-var MAX_FILTER_DEPTH = 30;
-
-// src/filters/operands.ts
-var RANGE_OPERATORS = ["gt", "lt", "gte", "lte"];
-var TEXT_OPERATORS = ["startsWith", "endsWith"];
-var EQUALITY_OPERATORS = ["eq", "ne"];
-var LIST_OPERATORS = ["in", "nin"];
-function operandKindOf(type) {
-  if (type === void 0) return void 0;
-  if (type === "number" || type === "number[]") return "number";
-  if (type === "boolean" || type === "boolean[]") return "boolean";
-  if (type === "geopoint") return "geopoint";
-  if (type.startsWith("vector[")) return "vector";
-  return "text";
-}
-function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function kindOfValue(value) {
-  if (isFiniteNumber(value)) return "number";
-  if (typeof value === "boolean") return "boolean";
-  if (typeof value === "string") return "text";
-  return void 0;
-}
-function invalid(message, fieldPath, operator) {
-  throw new NarsilError(ErrorCodes.SEARCH_INVALID_FILTER, message, { fieldPath, operator });
-}
-function requireFieldKind(fieldPath, operator, type, accepted) {
-  const kind = operandKindOf(type);
-  if (kind === void 0 || accepted.includes(kind)) return;
-  invalid(
-    `The engine applies "${operator}" to ${accepted.join(" or ")} fields alone, and the schema declares field "${fieldPath}" as "${type}"`,
-    fieldPath,
-    operator
-  );
+function polygonBoxes(polygon) {
+  if (polygon.length < MIN_POLYGON_POINTS) return [];
+  const unwrap = crossesAntimeridian(polygon);
+  let south = Number.POSITIVE_INFINITY;
+  let north = Number.NEGATIVE_INFINITY;
+  let west = Number.POSITIVE_INFINITY;
+  let east = Number.NEGATIVE_INFINITY;
+  for (const point of polygon) {
+    const lon = unwrap ? eastward(point.lon) : point.lon;
+    south = Math.min(south, point.lat);
+    north = Math.max(north, point.lat);
+    west = Math.min(west, lon);
+    east = Math.max(east, lon);
+  }
+  if (west >= MAX_LONGITUDE_DEGREES)
+    return longitudeBoxes(south, north, west - FULL_TURN_DEGREES, east - FULL_TURN_DEGREES);
+  return longitudeBoxes(south, north, west, east);
 }
-function requireTextRangeField(fieldPath, operator, type) {
-  const parsed = parsedTypeOf(type);
-  if (parsed?.sortable && (parsed.base === "string" || parsed.base === "verbatim")) return;
-  const declared = type === void 0 ? `the schema has no field "${fieldPath}"` : `field "${fieldPath}" has type "${type}"`;
-  invalid(
-    `The engine applies "${operator}" with a text bound to a "string" or "verbatim" field whose type includes "sortable", but ${declared}`,
-    fieldPath,
-    operator
-  );
+
+// src/filters/operands/geo.ts
+function requireFlag(fieldPath, operator, flag, value) {
+  if (value === void 0 || typeof value === "boolean") return;
+  invalid(`"${operator}.${flag}" on field "${fieldPath}" must be true or false`, fieldPath, operator);
 }
 function requireRadius(fieldPath, radius) {
   const circle = radius;
@@ -1212,6 +1411,15 @@ function requireRadius(fieldPath, radius) {
       invalid(`"radius.${key}" on field "${fieldPath}" must be a finite number`, fieldPath, "radius");
     }
   }
+  if (typeof circle.unit !== "string" || !Object.hasOwn(GEO_UNIT_METRES, circle.unit)) {
+    invalid(
+      `"radius.unit" on field "${fieldPath}" must be one of ${Object.keys(GEO_UNIT_METRES).join(", ")}, and this filter sets ${String(circle.unit)}`,
+      fieldPath,
+      "radius"
+    );
+  }
+  requireFlag(fieldPath, "radius", "inside", circle.inside);
+  requireFlag(fieldPath, "radius", "highPrecision", circle.highPrecision);
   if (circle.distance < 0) {
     invalid(
       `"radius.distance" on field "${fieldPath}" must be zero or more, and this filter sets ${String(circle.distance)}`,
@@ -1219,13 +1427,197 @@ function requireRadius(fieldPath, radius) {
       "radius"
     );
   }
+  if (!isLatitude(circle.lat)) {
+    invalid(
+      `"radius.lat" on field "${fieldPath}" must be from -${MAX_LATITUDE_DEGREES} to ${MAX_LATITUDE_DEGREES}, and this filter sets ${String(circle.lat)}`,
+      fieldPath,
+      "radius"
+    );
+  }
+  if (!isLongitude(circle.lon)) {
+    invalid(
+      `"radius.lon" on field "${fieldPath}" must be from -${MAX_LONGITUDE_DEGREES} to ${MAX_LONGITUDE_DEGREES}, and this filter sets ${String(circle.lon)}`,
+      fieldPath,
+      "radius"
+    );
+  }
+}
+function requireGeoOperands(fieldPath, filter) {
+  if (filter.radius !== void 0) requireRadius(fieldPath, filter.radius);
+  if (filter.polygon === void 0) return;
+  if (!isObjectRecord(filter.polygon)) {
+    invalid(`"polygon" on field "${fieldPath}" must be an object`, fieldPath, "polygon");
+  }
+  requireFlag(fieldPath, "polygon", "inside", filter.polygon.inside);
+  const points = filter.polygon.points;
+  if (Array.isArray(points)) requireListLength(fieldPath, "polygon", points);
+  requirePolygonRing(points);
+}
+
+// src/filters/operands/lists.ts
+var WHOLE_VALUE_OPERATORS = ["eq", "ne", "in", "nin", "startsWith", "endsWith", "matchesAny", "containsAll"];
+var ELEMENT_OPERATORS = ["matchesAny", "containsAll"];
+var PRESENCE_OPERATORS = ["exists", "notExists", "isEmpty", "isNotEmpty"];
+var SIZE_OPERATORS = ["eq", "ne", "gt", "gte", "lt", "lte", "between"];
+var SIZE_OPERATOR_SET = new Set(SIZE_OPERATORS);
+var ELEMENT_KIND_BY_BASE = {
+  "number[]": "number",
+  "boolean[]": "boolean",
+  "enum[]": "text",
+  "string[]": "text",
+  "verbatim[]": "text"
+};
+function requireWholeValueIndex(fieldPath, filter, type) {
+  const parsed = parsedTypeOf(type);
+  if (parsed === void 0 || parsed.pattern || parsed.base !== "string" && parsed.base !== "string[]") return;
+  for (const operator of WHOLE_VALUE_OPERATORS) {
+    if (filter[operator] === void 0) continue;
+    invalid(
+      `"${operator}" compares whole values of field "${fieldPath}", which the engine finds only through a pattern index. A "${parsed.base}" field keeps a pattern index where its type includes "pattern", so declare the field as "${parsed.base}:pattern" in a new index to filter it this way`,
+      fieldPath,
+      operator
+    );
+  }
+}
+function requirePresenceOperands(fieldPath, filter) {
+  for (const operator of PRESENCE_OPERATORS) {
+    const operand = filter[operator];
+    if (operand !== void 0 && typeof operand !== "boolean") {
+      invalid(`"${operator}" on field "${fieldPath}" must be true or false`, fieldPath, operator);
+    }
+  }
+}
+function listElementKind(fieldPath, operator, type) {
+  const base = parsedTypeOf(type)?.base;
+  const kind = base === void 0 ? void 0 : ELEMENT_KIND_BY_BASE[base];
+  if (kind !== void 0) return kind;
+  return invalid(
+    `"${operator}" tests the elements of a list field, while the schema declares field "${fieldPath}" as "${type}"`,
+    fieldPath,
+    operator
+  );
+}
+function requireElementOperands(fieldPath, filter, type) {
+  for (const operator of ELEMENT_OPERATORS) {
+    const values = filter[operator];
+    if (values === void 0) continue;
+    if (!Array.isArray(values)) invalid(`"${operator}" on field "${fieldPath}" must be a list`, fieldPath, operator);
+    requireListLength(fieldPath, operator, values);
+    const kind = listElementKind(fieldPath, operator, type);
+    if (values.some((value) => kindOfValue(value) !== kind)) {
+      invalid(
+        `Every value of "${operator}" on field "${fieldPath}" must be a ${kind === "text" ? "string" : kind === "number" ? "finite number" : "boolean"}, because the field holds a list of them`,
+        fieldPath,
+        operator
+      );
+    }
+  }
+}
+function requireSizeOperands(fieldPath, filter, type) {
+  const size = filter.size;
+  if (size === void 0) return;
+  if (!isObjectRecord(size)) invalid(`"size" on field "${fieldPath}" must be a comparison object`, fieldPath, "size");
+  listElementKind(fieldPath, "size", type);
+  for (const [operator, operand] of Object.entries(size)) {
+    if (!SIZE_OPERATOR_SET.has(operator)) {
+      invalid(
+        `"size" on field "${fieldPath}" takes ${SIZE_OPERATORS.join(", ")}, while "${operator}" is none of them`,
+        fieldPath,
+        "size"
+      );
+    }
+    const bounds = operator === "between" ? operand : [operand];
+    if (!Array.isArray(bounds) || bounds.length !== (operator === "between" ? 2 : 1) || !bounds.every(isFiniteNumber)) {
+      invalid(
+        `"size.${operator}" on field "${fieldPath}" must be ${operator === "between" ? "two finite numbers, the lower bound first" : "a finite number"}`,
+        fieldPath,
+        "size"
+      );
+    }
+  }
 }
+
+// src/filters/operands/pattern.ts
+function requirePatternField(fieldPath, operator, type) {
+  if (parsedTypeOf(type)?.pattern === true) return;
+  const declared = type === void 0 ? `The schema declares no field "${fieldPath}"` : `Field "${fieldPath}" has type "${type}"`;
+  invalid(
+    `"${operator}" applies only to a pattern field, because only a pattern field has a pattern index. A pattern field is a "verbatim" field, or a text field whose type includes "pattern". ${declared}`,
+    fieldPath,
+    operator
+  );
+}
+function requirePatternText(fieldPath, operator, text, caseFold) {
+  if (exceedsCodePoints(text, MAX_PATTERN_TEXT_CODE_POINTS)) {
+    invalid(
+      `The text of "${operator}" on pattern field "${fieldPath}" holds more than ${MAX_PATTERN_TEXT_CODE_POINTS} code points`,
+      fieldPath,
+      operator
+    );
+  }
+  if (caseFold && foldedCodePointCount(text) > MAX_PATTERN_POSITIONS) {
+    invalid(
+      `The text of "${operator}" on pattern field "${fieldPath}" has a case fold of more than ${MAX_PATTERN_POSITIONS} code points, while a pattern holds at most ${MAX_PATTERN_POSITIONS} positions`,
+      fieldPath,
+      operator
+    );
+  }
+}
+var ELEMENT_OPERATORS2 = ["matchesAny", "containsAll"];
+function requirePatternOperands(fieldPath, filter, type) {
+  if (filter.contains !== void 0) {
+    if (typeof filter.contains !== "string") {
+      invalid(`"contains" on field "${fieldPath}" must be a string`, fieldPath, "contains");
+    }
+    requirePatternField(fieldPath, "contains", type);
+  }
+  if (filter.caseFold !== void 0) {
+    if (typeof filter.caseFold !== "boolean") {
+      invalid(`"caseFold" on field "${fieldPath}" must be true or false`, fieldPath, "caseFold");
+    }
+    requirePatternField(fieldPath, "caseFold", type);
+  }
+  if (parsedTypeOf(type)?.pattern !== true) return;
+  const caseFold = filter.caseFold === true;
+  for (const operator of PATTERN_TEST_OPERATORS) {
+    const operand = filter[operator];
+    if (typeof operand === "string") requirePatternText(fieldPath, operator, operand, caseFold);
+    if (!Array.isArray(operand)) continue;
+    for (const text of operand) {
+      if (typeof text === "string") requirePatternText(fieldPath, operator, text, caseFold);
+    }
+  }
+  for (const operator of ELEMENT_OPERATORS2) {
+    const operand = filter[operator];
+    if (!Array.isArray(operand)) continue;
+    for (const text of operand) {
+      if (typeof text === "string") requirePatternText(fieldPath, operator, text, false);
+    }
+  }
+}
+function requireWellFormedText(fieldPath, filter) {
+  for (const [operator, operand] of Object.entries(filter)) {
+    const texts = Array.isArray(operand) ? operand : [operand];
+    for (const text of texts) {
+      if (typeof text !== "string" || !holdsUnpairedSurrogate(text)) continue;
+      invalid(
+        `The text of "${operator}" on field "${fieldPath}" holds an unpaired surrogate, the half of a character such as an emoji whose other half is missing, so no stored value can hold it`,
+        fieldPath,
+        operator
+      );
+    }
+  }
+}
+
+// src/filters/operands/index.ts
+var RANGE_OPERATORS = ["gt", "lt", "gte", "lte"];
+var TEXT_OPERATORS = ["startsWith", "endsWith"];
+var EQUALITY_OPERATORS = ["eq", "ne"];
+var LIST_OPERATORS = ["in", "nin"];
+var GEO_OPERATORS = ["radius", "polygon"];
 function invalidShape(message) {
   throw new NarsilError(ErrorCodes.SEARCH_INVALID_FILTER, message);
 }
-function isObjectRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 function undeclaredFieldOnStrictIndex(field, option) {
   return new NarsilError(
     ErrorCodes.SEARCH_INVALID_FIELD,
@@ -1233,34 +1625,14 @@ function undeclaredFieldOnStrictIndex(field, option) {
     { field, option }
   );
 }
-function requireValidExpression(expression, rules, depth) {
-  if (depth > MAX_FILTER_DEPTH) invalidShape(`A filter expression nests at most ${MAX_FILTER_DEPTH} levels deep`);
-  if (!isObjectRecord(expression)) invalidShape("Each filter expression must be an object");
-  const { fields, and, or, not } = expression;
-  if (fields !== void 0) {
-    if (!isObjectRecord(fields)) invalidShape('"fields" in a filter expression must be an object keyed by field path');
-    for (const [fieldPath, filter] of Object.entries(fields)) {
-      if (rules.declaredOnly && !Object.hasOwn(rules.fieldTypes, fieldPath)) {
-        throw undeclaredFieldOnStrictIndex(fieldPath, "filter");
-      }
-      if (isObjectRecord(filter)) requireValidOperands(fieldPath, filter, rules.fieldTypes[fieldPath]);
-    }
-  }
-  for (const [clause, list] of [
-    ["and", and],
-    ["or", or]
-  ]) {
-    if (list === void 0) continue;
-    if (!Array.isArray(list)) invalidShape(`"${clause}" in a filter expression must be a list of filter expressions`);
-    for (const nested of list) requireValidExpression(nested, rules, depth + 1);
-  }
-  if (not !== void 0) requireValidExpression(not, rules, depth + 1);
-}
-function requireValidFilter(expression, fieldTypes, declaredOnly = false) {
-  if (expression === void 0 || expression === null) return;
-  requireValidExpression(expression, { fieldTypes, declaredOnly }, 0);
+function undeclaredFilterField(field) {
+  return new NarsilError(
+    ErrorCodes.SEARCH_INVALID_FIELD,
+    `The schema declares no field "${field}", while the engine answers a filter only from the indexes that it keeps for declared fields. Declare the field in the schema of a new index to filter by it`,
+    { field, option: "filter" }
+  );
 }
-function requireValidOperands(fieldPath, filter, type) {
+function requireRangeOperands(fieldPath, filter, type) {
   for (const operator of RANGE_OPERATORS) {
     const bound = filter[operator];
     if (bound === void 0) continue;
@@ -1273,22 +1645,23 @@ function requireValidOperands(fieldPath, filter, type) {
     }
     requireFieldKind(fieldPath, operator, type, ["number"]);
   }
-  if (filter.between !== void 0) {
-    const bounds = filter.between;
-    const isPair = Array.isArray(bounds) && bounds.length === 2;
-    if (isPair && typeof bounds[0] === "string" && typeof bounds[1] === "string") {
-      requireTextRangeField(fieldPath, "between", type);
-    } else {
-      if (!isPair || !isFiniteNumber(bounds[0]) || !isFiniteNumber(bounds[1])) {
-        invalid(
-          `"between" on field "${fieldPath}" must be two finite numbers or two strings, the lower bound first`,
-          fieldPath,
-          "between"
-        );
-      }
-      requireFieldKind(fieldPath, "between", type, ["number"]);
-    }
+  if (filter.between === void 0) return;
+  const bounds = filter.between;
+  const isPair = Array.isArray(bounds) && bounds.length === 2;
+  if (isPair && typeof bounds[0] === "string" && typeof bounds[1] === "string") {
+    requireTextRangeField(fieldPath, "between", type);
+    return;
   }
+  if (!isPair || !isFiniteNumber(bounds[0]) || !isFiniteNumber(bounds[1])) {
+    invalid(
+      `"between" on field "${fieldPath}" must be two finite numbers or two strings, the lower bound first`,
+      fieldPath,
+      "between"
+    );
+  }
+  requireFieldKind(fieldPath, "between", type, ["number"]);
+}
+function requireValueOperands(fieldPath, filter, type) {
   for (const operator of TEXT_OPERATORS) {
     if (filter[operator] === void 0) continue;
     if (typeof filter[operator] !== "string") {
@@ -1314,22 +1687,81 @@ function requireValidOperands(fieldPath, filter, type) {
     if (!Array.isArray(values) || values.some((value) => typeof value !== "string")) {
       invalid(`"${operator}" on field "${fieldPath}" must be a list of strings`, fieldPath, operator);
     }
+    requireListLength(fieldPath, operator, values);
     requireFieldKind(fieldPath, operator, type, ["text"]);
   }
-  if (filter.size !== void 0) {
-    const size = filter.size;
-    if (size === null || typeof size !== "object") {
-      invalid(`"size" on field "${fieldPath}" must be a comparison object`, fieldPath, "size");
-    }
-    requireValidOperands(`${fieldPath}.size`, size, "number");
+  for (const operator of GEO_OPERATORS) {
+    if (filter[operator] !== void 0) requireFieldKind(fieldPath, operator, type, ["geopoint"]);
   }
-  if (filter.radius !== void 0) requireRadius(fieldPath, filter.radius);
-  if (filter.polygon !== void 0) {
-    if (!isObjectRecord(filter.polygon)) {
-      invalid(`"polygon" on field "${fieldPath}" must be an object`, fieldPath, "polygon");
-    }
-    requirePolygonRing(filter.polygon.points);
+}
+function requireValidOperands(fieldPath, filter, type) {
+  requireWellFormedText(fieldPath, filter);
+  requireRangeOperands(fieldPath, filter, type);
+  requireValueOperands(fieldPath, filter, type);
+  requireWholeValueIndex(fieldPath, filter, type);
+  requirePresenceOperands(fieldPath, filter);
+  requireElementOperands(fieldPath, filter, type);
+  requireSizeOperands(fieldPath, filter, type);
+  requirePatternOperands(fieldPath, filter, type);
+  requireGeoOperands(fieldPath, filter);
+}
+function filterTestCount(expression) {
+  if (!isObjectRecord(expression)) return 0;
+  const fieldFilters = isObjectRecord(expression.fields) ? Object.values(expression.fields) : [];
+  let tests = fieldFilters.length === 0 && !holdsNestedExpressions(expression) ? 1 : 0;
+  for (const filter of fieldFilters) tests += isObjectRecord(filter) ? testsIn(filter) : 1;
+  for (const list of [expression.and, expression.or]) {
+    if (Array.isArray(list)) for (const nested of list) tests += filterTestCount(nested);
+  }
+  return tests + filterTestCount(expression.not);
+}
+function testsIn(filter) {
+  let tests = 0;
+  for (const [operator, operand] of Object.entries(filter)) {
+    if (operator === "caseFold") continue;
+    tests += operator === "size" && isObjectRecord(operand) ? Math.max(1, Object.keys(operand).length) : 1;
+  }
+  return Math.max(1, tests);
+}
+function countTests(walk, tests) {
+  walk.tests += tests;
+  if (walk.tests > MAX_FILTER_TESTS) {
+    invalidShape(`A filter holds at most ${MAX_FILTER_TESTS} tests across all of its fields and nested expressions`);
+  }
+}
+function holdsNestedExpressions(expression) {
+  const { and, or, not } = expression;
+  return Array.isArray(and) && and.length > 0 || Array.isArray(or) && or.length > 0 || not !== void 0;
+}
+function requireValidExpression(expression, walk, depth) {
+  if (depth > MAX_FILTER_DEPTH) invalidShape(`A filter expression nests at most ${MAX_FILTER_DEPTH} levels deep`);
+  if (!isObjectRecord(expression)) invalidShape("Each filter expression must be an object");
+  const { fields, and, or, not } = expression;
+  if (fields !== void 0 && !isObjectRecord(fields)) {
+    invalidShape('"fields" in a filter expression must be an object keyed by field path');
+  }
+  const fieldFilters = Object.entries(fields ?? {});
+  if (fieldFilters.length === 0 && !holdsNestedExpressions(expression)) countTests(walk, 1);
+  for (const [fieldPath, filter] of fieldFilters) {
+    const type = walk.fieldTypes[fieldPath];
+    if (!Object.hasOwn(walk.fieldTypes, fieldPath) || type === void 0) throw undeclaredFilterField(fieldPath);
+    if (!isObjectRecord(filter)) invalidShape(`The filter on field "${fieldPath}" must be an object of tests`);
+    countTests(walk, testsIn(filter));
+    requireValidOperands(fieldPath, filter, type);
+  }
+  for (const [clause, list] of [
+    ["and", and],
+    ["or", or]
+  ]) {
+    if (list === void 0) continue;
+    if (!Array.isArray(list)) invalidShape(`"${clause}" in a filter expression must be a list of filter expressions`);
+    for (const nested of list) requireValidExpression(nested, walk, depth + 1);
   }
+  if (not !== void 0) requireValidExpression(not, walk, depth + 1);
+}
+function requireValidFilter(expression, fieldTypes) {
+  if (expression === void 0 || expression === null) return;
+  requireValidExpression(expression, { fieldTypes, tests: 0 }, 0);
 }
 
 // src/search/sorting.ts
@@ -1679,7 +2111,11 @@ function prepareFulltextQuery(partition, params, language, schema, options) {
   }
   let filterBitset;
   if (params.filters) {
-    filterBitset = partition.applyFiltersBitset(params.filters, schema);
+    filterBitset = partition.applyFiltersBitset(
+      params.filters,
+      schema,
+      options?.patternWork ?? createPatternWorkMeter()
+    );
     if (bitsetIsEmpty(filterBitset)) return null;
   }
   return { queryTokens, prefixExpansion, filterBitset };
@@ -1922,7 +2358,8 @@ function resolveEffectiveMode(config) {
 function buildSearchOptions(base, globalStats) {
   return {
     ...base,
-    globalStats: globalStats ?? base?.globalStats
+    globalStats: globalStats ?? base?.globalStats,
+    patternWork: base?.patternWork ?? createPatternWorkMeter()
   };
 }
 function dispatchWithDispatcher(partitions, params, language, schema, options, dispatcher) {
@@ -1949,8 +2386,12 @@ function countsWithoutScores(params) {
 }
 function fanOutMatchCount(manager, params, language, schema, options) {
   let count = 0;
+  const searchOptions = {
+    ...options?.searchOptions,
+    patternWork: options?.searchOptions?.patternWork ?? createPatternWorkMeter()
+  };
   for (const partition of partitionsIn(manager, options?.partitionIds)) {
-    const matches = fulltextMatches(partition, params, language, schema, options?.searchOptions);
+    const matches = fulltextMatches(partition, params, language, schema, searchOptions);
     if (matches !== null) count += matches.count;
   }
   return count;
@@ -2132,4 +2573,4 @@ function setNestedValue(obj, path, value) {
   current[segments[segments.length - 1]] = value;
 }
 
-export { DEG_TO_RAD, MAX_FILTER_DEPTH, MIN_POLYGON_POINTS, VINCENTY_CONVERGENCE_THRESHOLD, VINCENTY_MAX_ITERATIONS, applyPagination, applyProjection, applySorting, bitsetAnd, bitsetFromSet, bitsetHas, bitsetNot, bitsetOr, bitsetSet, boundedLevenshtein, clampRowCount, clearNormalizationCache, cloneProjected, collectQueryTermStats, computeFacets, configureNormalizationCache, countsWithoutScores, createBitSet, decodePageCursor, encodePageCursor, everyValueFacetConfig, fanOutMatchCount, fanOutQuery, fnv1a, fnv1aBytes, fnv1aUint32s, fulltextMatches, fuzzyPrefixOf, fuzzyTermMatches, getAllInternalDocIds, getFieldValueByInternalId, getFlatSchema, getNestedValue, getNormalizationCacheSize, getOrCreateFieldNameIndex, kWayMerge, mergeFacets, mergePartitionStats, normalizeSort, oversampledFacetConfig, oversampledShardSize, partitionsIn, polygonContainment, projectionKeepsField, pruneStatsToQueryTerms, readSortValues, requireMatchingCursor, requirePolygonRing, requireSortableFields, requireValidFilter, requireValidOperands, requireWithinResultWindow, resetNormalizationCache, resolveProjection, sanitizeGlobalStats, setNestedValue, sortModesOf, sortSignatureEntry, sortSignatureOf, textFieldsChanged, tokenize, tokenizeIterator, tokenizeOptions, undeclaredFieldOnStrictIndex, visitTokens };
+export { GEO_UNIT_METRES, MAX_FILTER_ARRAY_SIZE, MAX_FILTER_DEPTH, MAX_FILTER_TESTS, applyPagination, applyProjection, applySorting, boundedLevenshtein, clampRowCount, clearNormalizationCache, cloneProjected, collectQueryTermStats, computeFacets, configureNormalizationCache, countsWithoutScores, coveringRanges, createPatternWorkMeter, decodePageCursor, encodePageCursor, everyValueFacetConfig, fanOutMatchCount, fanOutQuery, filterTestCount, fnv1a, fnv1aBytes, fnv1aUint32s, fulltextMatches, fuzzyPrefixOf, fuzzyTermMatches, getFieldValueByInternalId, getFlatSchema, getNestedValue, getNormalizationCacheSize, getOrCreateFieldNameIndex, joinPatternWorkMeter, kWayMerge, locationCode, mergeFacets, mergePartitionStats, normalizeSort, oversampledFacetConfig, oversampledShardSize, partitionsIn, polygonBoxes, polygonContainment, projectionKeepsField, pruneStatsToQueryTerms, radiusBoxes, readSortValues, requireMatchingCursor, requireSortableFields, requireValidFilter, requireValidOperands, requireWithinResultWindow, resetNormalizationCache, resolveProjection, sanitizeGlobalStats, setNestedValue, sortModesOf, sortSignatureEntry, sortSignatureOf, textFieldsChanged, tokenize, tokenizeIterator, tokenizeOptions, undeclaredFieldOnStrictIndex, undeclaredFilterField, visitTokens };