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

package/dist/index.browser.mjs

@@ -33,6 +33,7 @@ var ErrorCodes = {
   SEARCH_INVALID_MODE: "SEARCH_INVALID_MODE",
   SEARCH_INVALID_CURSOR: "SEARCH_INVALID_CURSOR",
   SEARCH_RESULT_WINDOW_EXCEEDED: "SEARCH_RESULT_WINDOW_EXCEEDED",
+  SEARCH_WORK_CAP_EXCEEDED: "SEARCH_WORK_CAP_EXCEEDED",
   LANGUAGE_NOT_SUPPORTED: "LANGUAGE_NOT_SUPPORTED",
   ENVELOPE_VERSION_MISMATCH: "ENVELOPE_VERSION_MISMATCH",
   ENVELOPE_INVALID_MAGIC: "ENVELOPE_INVALID_MAGIC",
@@ -209,6 +210,288 @@ function resolveIndexAnalysis(config) {
   };
 }
 
+// src/core/pattern-index/platform.browser.ts
+function platformPatternSearch() {
+  return null;
+}
+
+// src/schema/constants.ts
+var MAX_NESTING_DEPTH = 4;
+var MAX_DOCUMENT_NESTING_DEPTH = 32;
+var DEFAULT_PATTERN_VALUE_LIMIT = 8192;
+var MIN_PATTERN_VALUE_LIMIT = 1;
+var MAX_PATTERN_VALUE_LIMIT = 65536;
+
+// src/schema/validator/shared.ts
+var VECTOR_PATTERN = /^vector\[(\d+)]$/;
+function isGeopointOrVectorType(fieldType) {
+  return fieldType === "geopoint" || fieldType !== void 0 && VECTOR_PATTERN.test(fieldType);
+}
+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/field-type.ts
+var FIELD_OPTION_ORDER = ["sortable", "pattern", "partial"];
+var OPTIONS_BY_BASE = {
+  string: FIELD_OPTION_ORDER,
+  "string[]": FIELD_OPTION_ORDER,
+  verbatim: ["sortable"],
+  "verbatim[]": ["sortable"],
+  number: [],
+  "number[]": [],
+  boolean: [],
+  "boolean[]": [],
+  enum: [],
+  "enum[]": [],
+  geopoint: [],
+  vector: []
+};
+var TYPE_SEPARATOR = ":";
+function isNamedBase(name) {
+  return name !== "vector" && Object.hasOwn(OPTIONS_BY_BASE, name);
+}
+function describeAllowedOptions(baseName, allowed) {
+  if (allowed.length === 0) return `the "${baseName}" type has no options`;
+  const quoted = allowed.map((option) => `"${option}"`);
+  if (quoted.length === 1) return `the only option of the "${baseName}" type is ${quoted[0]}`;
+  return `the options of the "${baseName}" type are ${quoted.slice(0, -1).join(", ")}, and ${quoted[quoted.length - 1]}`;
+}
+function invalidType(path, type, message) {
+  throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, message, { field: path, type });
+}
+function parseBase(baseName, path, type) {
+  if (isNamedBase(baseName)) return { base: baseName, dimension: 0 };
+  const vectorMatch = VECTOR_PATTERN.exec(baseName);
+  if (vectorMatch === null) {
+    invalidType(path, type, `Field "${path}" has an unsupported type: "${type}"`);
+  }
+  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 }
+    );
+  }
+  return { base: "vector", dimension };
+}
+function parseFieldType(type, path) {
+  const separatorIndex = type.indexOf(TYPE_SEPARATOR);
+  const baseName = separatorIndex === -1 ? type : type.slice(0, separatorIndex);
+  const { base, dimension } = parseBase(baseName, path, type);
+  const allowed = OPTIONS_BY_BASE[base];
+  const options = /* @__PURE__ */ new Set();
+  if (separatorIndex !== -1) {
+    for (const option of type.slice(separatorIndex + 1).split(TYPE_SEPARATOR)) {
+      if (!allowed.includes(option)) {
+        invalidType(
+          path,
+          type,
+          `Field "${path}" has type "${type}" with the option "${option}", but ${describeAllowedOptions(baseName, allowed)}`
+        );
+      }
+      if (options.has(option)) {
+        invalidType(path, type, `Field "${path}" has the "${option}" option twice in type "${type}"`);
+      }
+      options.add(option);
+    }
+  }
+  const ordered = FIELD_OPTION_ORDER.filter((option) => options.has(option));
+  const verbatim = base === "verbatim" || base === "verbatim[]";
+  return {
+    type: [baseName, ...ordered].join(TYPE_SEPARATOR),
+    base,
+    sortable: options.has("sortable"),
+    pattern: verbatim || options.has("pattern"),
+    partial: options.has("partial"),
+    dimension
+  };
+}
+function parsedTypeOf(type) {
+  if (type === void 0) return void 0;
+  try {
+    return parseFieldType(type, "");
+  } catch {
+    return void 0;
+  }
+}
+function withSortableOption(parsed) {
+  if (parsed.sortable) return parsed.type;
+  const separatorIndex = parsed.type.indexOf(TYPE_SEPARATOR);
+  const baseName = separatorIndex === -1 ? parsed.type : parsed.type.slice(0, separatorIndex);
+  return parseFieldType(`${baseName}${TYPE_SEPARATOR}sortable${parsed.type.slice(baseName.length)}`, "").type;
+}
+function isListBase(base) {
+  return base.endsWith("[]");
+}
+function isWordIndexedBase(base) {
+  return base === "string" || base === "string[]";
+}
+function isSingleStringFieldType(fieldType) {
+  return parsedTypeOf(fieldType)?.base === "string";
+}
+function isWordIndexedFieldType(fieldType) {
+  const parsed = parsedTypeOf(fieldType);
+  return parsed !== void 0 && isWordIndexedBase(parsed.base);
+}
+function isStringValuedBase(base) {
+  return base === "string" || base === "string[]" || base === "verbatim" || base === "verbatim[]";
+}
+
+// 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 }
+    );
+  }
+  let canonical = null;
+  const replace = (field, value) => {
+    if (canonical === null) canonical = { ...schema };
+    canonical[field] = value;
+  };
+  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)) {
+      const nested = validateSchemaFields(type, depth + 1, path);
+      if (nested !== type) replace(field, nested);
+      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)
+        }
+      );
+    }
+    const parsed = parseFieldType(type, path);
+    if (parsed.type !== type) replace(field, parsed.type);
+  }
+  return canonical ?? schema;
+}
+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");
+  }
+  return validateSchemaFields(schema, 1, "");
+}
+function requireValidFieldTypes(flatSchema) {
+  for (const [path, type] of Object.entries(flatSchema)) {
+    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) }
+      );
+    }
+    parseFieldType(type, path);
+  }
+}
+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;
+    }
+  }
+}
+var flattenedSchemas = /* @__PURE__ */ new WeakMap();
+function flattenSchema(schema) {
+  const cached = flattenedSchemas.get(schema);
+  if (cached !== void 0) return cached;
+  const result = /* @__PURE__ */ Object.create(null);
+  flattenRecursive(schema, "", result);
+  flattenedSchemas.set(schema, Object.freeze(result));
+  return result;
+}
+var parsedSchemas = /* @__PURE__ */ new WeakMap();
+function schemaFieldsOf(schema) {
+  const cached = parsedSchemas.get(schema);
+  if (cached !== void 0) return cached;
+  const fields = [];
+  for (const [path, type] of Object.entries(flattenSchema(schema))) {
+    fields.push({ ...parseFieldType(type, path), path });
+  }
+  const frozen = Object.freeze(fields);
+  parsedSchemas.set(schema, frozen);
+  return frozen;
+}
+function extractVectorFieldsFromSchema(schema) {
+  const result = /* @__PURE__ */ new Map();
+  for (const field of schemaFieldsOf(schema)) {
+    if (field.base === "vector") result.set(field.path, field.dimension);
+  }
+  return result;
+}
+
+// src/core/pattern-index/registry.ts
+var registered = null;
+function isPatternSearchModule(value) {
+  return value !== null && typeof value === "object" && value.name === "pattern" && "createIndex" in value && typeof value.createIndex === "function" && "readArrays" in value && typeof value.readArrays === "function" && "mergeArrays" in value && typeof value.mergeArrays === "function" && "matchInto" in value && typeof value.matchInto === "function";
+}
+function registerPatternSearch(module) {
+  if (!isPatternSearchModule(module)) {
+    throw new NarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      'registerPatternSearch takes the patternSearch object that "@delali/narsil/pattern" exports'
+    );
+  }
+  registered = module;
+}
+function availablePatternSearch() {
+  return registered ?? platformPatternSearch();
+}
+function requirePatternSearchFor(schema) {
+  for (const { path, pattern } of schemaFieldsOf(schema)) {
+    if (pattern) requirePatternSearch(path);
+  }
+}
+function requirePatternSearch(fieldPath) {
+  const module = availablePatternSearch();
+  if (module !== null) return module;
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `Field "${fieldPath}" is a pattern field, but this bundle contains no pattern search code. Add import { patternSearch } from '@delali/narsil/pattern', then call registerPatternSearch(patternSearch) before you create or load the index`,
+    { field: fieldPath }
+  );
+}
+
 // src/core/tokenizer/constants.ts
 var TOKEN_CACHE_SIZE_FLOOR = 5e4;
 var TOKEN_CACHE_SIZE_CEILING = 2e6;
@@ -1820,7 +2103,8 @@ var NARSIL_CONFIG_KEYS = {
   embeddingAdapters: true,
   durability: true,
   analysis: true,
-  lifecycle: true
+  lifecycle: true,
+  patternWorkCap: true
 };
 var DURABILITY_CONFIG_KEYS = {
   tier: true,
@@ -1861,176 +2145,71 @@ function requireKnownKeys(section, value, known) {
     );
   }
 }
-function requireNamedPlugins(plugins) {
-  if (plugins === void 0) return;
-  if (!Array.isArray(plugins)) {
-    throw new NarsilError(ErrorCodes.CONFIG_INVALID, 'The configuration sets "plugins" to something other than a list');
-  }
-  plugins.forEach((plugin, position) => {
-    const name = plugin?.name;
-    if (typeof name !== "string" || name.trim().length === 0) {
-      throw new NarsilError(
-        ErrorCodes.CONFIG_INVALID,
-        `The plugin at position ${position} carries no name, and the engine names each plugin in its errors and event payloads`,
-        { position }
-      );
-    }
-  });
-}
-function requireKnownConfig(config) {
-  if (config === void 0) return;
-  requireKnownKeys("", config, NARSIL_CONFIG_KEYS);
-  requireKnownKeys("durability.", config.durability, DURABILITY_CONFIG_KEYS);
-  requireKnownKeys("workers.", config.workers, WORKER_CONFIG_KEYS);
-  requireKnownKeys("lifecycle.", config.lifecycle, LIFECYCLE_CONFIG_KEYS);
-  requireKnownKeys("analysis.", config.analysis, ANALYSIS_CONFIG_KEYS);
-  requireNamedPlugins(config.plugins);
-}
-
-// src/core/id-generator.ts
-function generateId() {
-  const bytes = new Uint8Array(16);
-  crypto.getRandomValues(bytes);
-  const now2 = Date.now();
-  bytes[0] = Math.floor(now2 / 2 ** 40);
-  bytes[1] = Math.floor(now2 / 2 ** 32) % 256;
-  bytes[2] = Math.floor(now2 / 2 ** 24) % 256;
-  bytes[3] = Math.floor(now2 / 2 ** 16) % 256;
-  bytes[4] = Math.floor(now2 / 2 ** 8) % 256;
-  bytes[5] = now2 % 256;
-  bytes[6] = bytes[6] & 15 | 112;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-
-// src/schema/constants.ts
-var MAX_NESTING_DEPTH = 4;
-var MAX_DOCUMENT_NESTING_DEPTH = 32;
-var DEFAULT_PATTERN_VALUE_LIMIT = 8192;
-var MIN_PATTERN_VALUE_LIMIT = 1;
-var MAX_PATTERN_VALUE_LIMIT = 65536;
-
-// src/schema/validator/shared.ts
-var VECTOR_PATTERN = /^vector\[(\d+)]$/;
-function isGeopointOrVectorType(fieldType) {
-  return fieldType === "geopoint" || fieldType !== void 0 && VECTOR_PATTERN.test(fieldType);
-}
-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/field-type.ts
-var FIELD_OPTION_ORDER = ["sortable", "pattern", "partial"];
-var OPTIONS_BY_BASE = {
-  string: FIELD_OPTION_ORDER,
-  "string[]": FIELD_OPTION_ORDER,
-  verbatim: ["sortable"],
-  "verbatim[]": ["sortable"],
-  number: [],
-  "number[]": [],
-  boolean: [],
-  "boolean[]": [],
-  enum: [],
-  "enum[]": [],
-  geopoint: [],
-  vector: []
-};
-var TYPE_SEPARATOR = ":";
-function isNamedBase(name) {
-  return name !== "vector" && Object.hasOwn(OPTIONS_BY_BASE, name);
-}
-function describeAllowedOptions(baseName, allowed) {
-  if (allowed.length === 0) return `the "${baseName}" type has no options`;
-  const quoted = allowed.map((option) => `"${option}"`);
-  if (quoted.length === 1) return `the only option of the "${baseName}" type is ${quoted[0]}`;
-  return `the options of the "${baseName}" type are ${quoted.slice(0, -1).join(", ")}, and ${quoted[quoted.length - 1]}`;
-}
-function invalidType(path, type, message) {
-  throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, message, { field: path, type });
-}
-function parseBase(baseName, path, type) {
-  if (isNamedBase(baseName)) return { base: baseName, dimension: 0 };
-  const vectorMatch = VECTOR_PATTERN.exec(baseName);
-  if (vectorMatch === null) {
-    invalidType(path, type, `Field "${path}" has an unsupported type: "${type}"`);
-  }
-  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 }
-    );
-  }
-  return { base: "vector", dimension };
-}
-function parseFieldType(type, path) {
-  const separatorIndex = type.indexOf(TYPE_SEPARATOR);
-  const baseName = separatorIndex === -1 ? type : type.slice(0, separatorIndex);
-  const { base, dimension } = parseBase(baseName, path, type);
-  const allowed = OPTIONS_BY_BASE[base];
-  const options = /* @__PURE__ */ new Set();
-  if (separatorIndex !== -1) {
-    for (const option of type.slice(separatorIndex + 1).split(TYPE_SEPARATOR)) {
-      if (!allowed.includes(option)) {
-        invalidType(
-          path,
-          type,
-          `Field "${path}" has type "${type}" with the option "${option}", but ${describeAllowedOptions(baseName, allowed)}`
-        );
-      }
-      if (options.has(option)) {
-        invalidType(path, type, `Field "${path}" has the "${option}" option twice in type "${type}"`);
-      }
-      options.add(option);
-    }
-  }
-  const ordered = FIELD_OPTION_ORDER.filter((option) => options.has(option));
-  const verbatim = base === "verbatim" || base === "verbatim[]";
-  return {
-    type: [baseName, ...ordered].join(TYPE_SEPARATOR),
-    base,
-    sortable: options.has("sortable"),
-    pattern: verbatim || options.has("pattern"),
-    partial: options.has("partial"),
-    dimension
-  };
-}
-function parsedTypeOf(type) {
-  if (type === void 0) return void 0;
-  try {
-    return parseFieldType(type, "");
-  } catch {
-    return void 0;
-  }
-}
-function withSortableOption(parsed) {
-  if (parsed.sortable) return parsed.type;
-  const separatorIndex = parsed.type.indexOf(TYPE_SEPARATOR);
-  const baseName = separatorIndex === -1 ? parsed.type : parsed.type.slice(0, separatorIndex);
-  return parseFieldType(`${baseName}${TYPE_SEPARATOR}sortable${parsed.type.slice(baseName.length)}`, "").type;
-}
-function isListBase(base) {
-  return base.endsWith("[]");
-}
-function isWordIndexedBase(base) {
-  return base === "string" || base === "string[]";
+function requireNamedPlugins(plugins) {
+  if (plugins === void 0) return;
+  if (!Array.isArray(plugins)) {
+    throw new NarsilError(ErrorCodes.CONFIG_INVALID, 'The configuration sets "plugins" to something other than a list');
+  }
+  plugins.forEach((plugin, position) => {
+    const name = plugin?.name;
+    if (typeof name !== "string" || name.trim().length === 0) {
+      throw new NarsilError(
+        ErrorCodes.CONFIG_INVALID,
+        `The plugin at position ${position} carries no name, and the engine names each plugin in its errors and event payloads`,
+        { position }
+      );
+    }
+  });
 }
-function isSingleStringFieldType(fieldType) {
-  return parsedTypeOf(fieldType)?.base === "string";
+function requireKnownConfig(config) {
+  if (config === void 0) return;
+  requireKnownKeys("", config, NARSIL_CONFIG_KEYS);
+  requireKnownKeys("durability.", config.durability, DURABILITY_CONFIG_KEYS);
+  requireKnownKeys("workers.", config.workers, WORKER_CONFIG_KEYS);
+  requireKnownKeys("lifecycle.", config.lifecycle, LIFECYCLE_CONFIG_KEYS);
+  requireKnownKeys("analysis.", config.analysis, ANALYSIS_CONFIG_KEYS);
+  requireNamedPlugins(config.plugins);
+  requireValidPatternWorkCap(config.patternWorkCap);
 }
-function isWordIndexedFieldType(fieldType) {
-  const parsed = parsedTypeOf(fieldType);
-  return parsed !== void 0 && isWordIndexedBase(parsed.base);
+function requireValidPatternWorkCap(cap) {
+  if (cap === void 0) return;
+  if (typeof cap === "number" && Number.isSafeInteger(cap) && cap >= 1) return;
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `The configuration sets "patternWorkCap" to ${String(cap)}, while the cap must be a whole number from 1 to ${Number.MAX_SAFE_INTEGER}`,
+    { setting: "patternWorkCap" }
+  );
 }
-function isStringValuedBase(base) {
-  return base === "string" || base === "string[]" || base === "verbatim" || base === "verbatim[]";
+
+// src/core/id-generator.ts
+function generateId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  const now2 = Date.now();
+  bytes[0] = Math.floor(now2 / 2 ** 40);
+  bytes[1] = Math.floor(now2 / 2 ** 32) % 256;
+  bytes[2] = Math.floor(now2 / 2 ** 24) % 256;
+  bytes[3] = Math.floor(now2 / 2 ** 16) % 256;
+  bytes[4] = Math.floor(now2 / 2 ** 8) % 256;
+  bytes[5] = now2 % 256;
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 
+// src/core/pattern-index/constants.ts
+var DEFAULT_PATTERN_WORK_CAP = 25e6;
+var MAX_PATTERN_TEXT_CODE_POINTS = 1024;
+var MAX_PATTERN_POSITIONS = 2048;
+var MATCHER_STATE_BUDGET_BYTES = 1e6;
+var MATCHER_CODE_POINT_BYTES = 8;
+var MATCHER_SIMULATION_BYTES_PER_POSITION = 16;
+var MATCHER_STATE_OVERHEAD_BYTES = 96;
+var PATTERN_WORK_FLUSH_UNITS = 65536;
+var PATTERN_RUN_CODE_POINTS = 3;
+var PATTERN_TEST_OPERATORS = ["eq", "ne", "in", "nin", "startsWith", "endsWith", "contains"];
+
 // src/core/ordering/code-points.ts
 function exceedsCodePoints(value, maximum) {
   if (value.length <= maximum) return false;
@@ -2048,6 +2227,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;
@@ -2061,6 +2265,29 @@ function compareCodePoints(a, b) {
   return adjustUtf16Unit(a.charCodeAt(i)) - adjustUtf16Unit(b.charCodeAt(i));
 }
 
+// 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)) {
@@ -2080,7 +2307,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`,
@@ -2090,7 +2317,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`,
@@ -2120,7 +2347,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`,
@@ -2145,11 +2372,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 }
+      );
     }
   }
 }
@@ -2180,11 +2408,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;
@@ -2242,6 +2470,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
@@ -2254,8 +2483,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`);
   }
@@ -2287,6 +2519,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);
     }
@@ -2353,9 +2586,20 @@ function validateDocument(document2, schema, patternValueLimit = DEFAULT_PATTERN
       received: typeof document2
     });
   }
+  requireIdFieldKey(document2);
   assertStorableDocument(document2, vectorFieldPaths(schema));
   validateDocumentFields(document2, schema, "", patternValueLimit);
 }
+function requireIdFieldKey(document2) {
+  if (!Object.hasOwn(document2, "id")) return;
+  const id = document2.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;
@@ -2403,124 +2647,6 @@ function validateRequiredFields(document2, required) {
   }
 }
 
-// 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 }
-    );
-  }
-  let canonical = null;
-  const replace = (field, value) => {
-    if (canonical === null) canonical = { ...schema };
-    canonical[field] = value;
-  };
-  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)) {
-      const nested = validateSchemaFields(type, depth + 1, path);
-      if (nested !== type) replace(field, nested);
-      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)
-        }
-      );
-    }
-    const parsed = parseFieldType(type, path);
-    if (parsed.type !== type) replace(field, parsed.type);
-  }
-  return canonical ?? schema;
-}
-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");
-  }
-  return validateSchemaFields(schema, 1, "");
-}
-function requireValidFieldTypes(flatSchema) {
-  for (const [path, type] of Object.entries(flatSchema)) {
-    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) }
-      );
-    }
-    parseFieldType(type, path);
-  }
-}
-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;
-    }
-  }
-}
-var flattenedSchemas = /* @__PURE__ */ new WeakMap();
-function flattenSchema(schema) {
-  const cached = flattenedSchemas.get(schema);
-  if (cached !== void 0) return cached;
-  const result = /* @__PURE__ */ Object.create(null);
-  flattenRecursive(schema, "", result);
-  flattenedSchemas.set(schema, Object.freeze(result));
-  return result;
-}
-var parsedSchemas = /* @__PURE__ */ new WeakMap();
-function schemaFieldsOf(schema) {
-  const cached = parsedSchemas.get(schema);
-  if (cached !== void 0) return cached;
-  const fields = [];
-  for (const [path, type] of Object.entries(flattenSchema(schema))) {
-    fields.push({ ...parseFieldType(type, path), path });
-  }
-  const frozen = Object.freeze(fields);
-  parsedSchemas.set(schema, frozen);
-  return frozen;
-}
-function extractVectorFieldsFromSchema(schema) {
-  const result = /* @__PURE__ */ new Map();
-  for (const field of schemaFieldsOf(schema)) {
-    if (field.base === "vector") result.set(field.path, field.dimension);
-  }
-  return result;
-}
-
 // src/vector/hnsw/constants.ts
 var MAX_LAYER_CAP = 32;
 var MAX_M = 512;
@@ -2868,6 +2994,44 @@ function sanitizeSurfaceForms(raw) {
   }
   return count > 0 ? result : void 0;
 }
+function patternIndexesToWire(pattern) {
+  if (pattern === void 0) return {};
+  const wire = /* @__PURE__ */ Object.create(null);
+  for (const [field, index] of Object.entries(pattern)) wire[field] = { doc_ids: index.docIds, runs: index.runs };
+  return { pattern: wire };
+}
+function isWireRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function corruptPatternEntry(field) {
+  return new NarsilError(
+    ErrorCodes.PERSISTENCE_LOAD_FAILED,
+    `The pattern entry of field "${field}" in this partition must hold a list of document IDs and a map of runs`,
+    { field }
+  );
+}
+function patternIndexesFromWire(raw) {
+  if (raw === void 0 || raw === null) return {};
+  if (!isWireRecord(raw)) {
+    throw new NarsilError(
+      ErrorCodes.PERSISTENCE_LOAD_FAILED,
+      "The pattern entry of this partition must be a map of fields"
+    );
+  }
+  const pattern = /* @__PURE__ */ Object.create(null);
+  for (const [field, index] of Object.entries(raw)) {
+    if (!isWireRecord(index) || !isWireRecord(index.runs) || !Array.isArray(index.doc_ids)) {
+      throw corruptPatternEntry(field);
+    }
+    const docIds = [];
+    for (const docId of index.doc_ids) {
+      if (typeof docId !== "string") throw corruptPatternEntry(field);
+      docIds.push(docId);
+    }
+    pattern[field] = { docIds, runs: index.runs };
+  }
+  return { pattern };
+}
 function validateHnswMetric(value) {
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
@@ -2939,7 +3103,8 @@ function wireToPartition(raw) {
       numeric,
       boolean,
       enum: raw.field_indexes?.enum ?? {},
-      geopoint
+      geopoint,
+      ...patternIndexesFromWire(raw.field_indexes?.pattern)
     },
     surfaceForms: sanitizeSurfaceForms(raw.surface_forms),
     vectorData,
@@ -3046,7 +3211,8 @@ function deserializePayloadV2(data) {
       numeric,
       boolean,
       enum: raw.field_indexes?.enum ?? {},
-      geopoint
+      geopoint,
+      ...patternIndexesFromWire(raw.field_indexes?.pattern)
     },
     surfaceForms: sanitizeSurfaceForms(raw.surface_forms),
     vectorData,
@@ -3096,6 +3262,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];
@@ -3109,9 +3279,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) {
@@ -3119,15 +3286,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;
@@ -3154,6 +3319,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;
@@ -4281,17 +4468,18 @@ function bitsetAnd(a, b) {
   }
   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 bitsetAndInto(target, other) {
+  const shared2 = Math.min(target.length, other.length);
+  for (let i = 0; i < shared2; i++) target[i] &= other[i];
+  target.fill(0, shared2);
+}
+function bitsetOrInto(target, other) {
+  const shared2 = Math.min(target.length, other.length);
+  for (let i = 0; i < shared2; i++) target[i] |= other[i];
+}
+function bitsetAndNotInto(target, removed) {
+  const shared2 = Math.min(target.length, removed.length);
+  for (let i = 0; i < shared2; i++) target[i] &= ~removed[i];
 }
 function bitsetNot(bs, capacity) {
   const result = new Uint32Array(bs.length);
@@ -4385,13 +4573,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 = "";
@@ -4524,19 +4705,116 @@ function computeFacets(state, matched, config, schema) {
     }
     result[fieldPath] = { values, count: entries.length, errorBound };
   }
-  return result;
+  return result;
+}
+
+// src/core/pattern-index/host.ts
+var PATTERN_HOST = { appendFoldedCodePoint };
+function patternIndexOf(indexes, fieldPath) {
+  let index = indexes.get(fieldPath);
+  if (index === void 0) {
+    index = requirePatternSearch(fieldPath).createIndex(PATTERN_HOST);
+    indexes.set(fieldPath, index);
+  }
+  return index;
 }
 
-// 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/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 level2 = LOCATION_CODE_BITS_PER_AXIS;
+  while (level2 > 0) {
+    const shift2 = LOCATION_CODE_BITS_PER_AXIS - level2;
+    const rows = (north >>> shift2) - (south >>> shift2) + 1;
+    const columns = (east >>> shift2) - (west >>> shift2) + 1;
+    if (rows * columns <= MAX_COVERING_CELLS) break;
+    level2--;
+  }
+  const shift = LOCATION_CODE_BITS_PER_AXIS - level2;
+  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, level2) * 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/haversine.ts
-var EARTH_RADIUS_METERS = 63710088e-1;
 function haversineDistance(lat1, lon1, lat2, lon2) {
   const phi1 = lat1 * DEG_TO_RAD;
   const phi2 = lat2 * DEG_TO_RAD;
@@ -4549,6 +4827,53 @@ function haversineDistance(lat1, lon1, lat2, lon2) {
   return EARTH_RADIUS_METERS * c;
 }
 
+// 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) {
   if (!Array.isArray(points) || points.length < MIN_POLYGON_POINTS) {
@@ -4560,11 +4885,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 }
     );
   });
 }
@@ -4597,20 +4929,35 @@ 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;
   };
 }
+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);
+}
 
 // src/geo/vincenty.ts
 var WGS84_A = 6378137;
@@ -4662,61 +5009,94 @@ function vincentyDistance(lat1, lon1, lat2, lon2) {
 }
 
 // src/geo/geo-index.ts
+function firstAtOrAfter(entries, code) {
+  let lo = 0;
+  let hi = entries.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (entries[mid].code < code) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
 function createGeoIndex() {
   const entries = [];
-  return {
-    get entries() {
-      return entries;
-    },
+  const byDocument = /* @__PURE__ */ new Map();
+  let sorted = true;
+  function ensureSorted() {
+    if (sorted) return;
+    entries.sort((left, right) => left.code - right.code || left.docId - right.docId);
+    sorted = true;
+  }
+  function removeEntry(internalId) {
+    const entry = byDocument.get(internalId);
+    if (entry === void 0) return;
+    byDocument.delete(internalId);
+    ensureSorted();
+    for (let at = firstAtOrAfter(entries, entry.code); at < entries.length; at++) {
+      if (entries[at] !== entry) continue;
+      entries.splice(at, 1);
+      return;
+    }
+  }
+  function matching(boxes, passes, inside) {
+    ensureSorted();
+    const within = /* @__PURE__ */ new Set();
+    for (const range of coveringRanges(boxes)) {
+      for (let at = firstAtOrAfter(entries, range.from); at < entries.length && entries[at].code < range.to; at++) {
+        if (passes(entries[at])) within.add(entries[at].docId);
+      }
+    }
+    if (inside) return within;
+    const outside = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      if (!within.has(entry.docId)) outside.add(entry.docId);
+    }
+    return outside;
+  }
+  const index = {
     insert(internalId, lat, lon) {
-      entries.push({ lat, lon, docId: internalId });
+      removeEntry(internalId);
+      const entry = { lat, lon, docId: internalId, code: locationCode(lat, lon) };
+      entries.push(entry);
+      byDocument.set(internalId, entry);
+      sorted = false;
     },
     remove(internalId) {
-      for (let i = entries.length - 1; i >= 0; i--) {
-        if (entries[i].docId === internalId) {
-          entries.splice(i, 1);
-          return;
-        }
-      }
+      removeEntry(internalId);
     },
     radiusQuery(lat, lon, distanceMeters, inside, highPrecision) {
-      const result = /* @__PURE__ */ new Set();
       const distanceFn = highPrecision ? vincentyDistance : haversineDistance;
-      for (let i = 0; i < entries.length; i++) {
-        const entry = entries[i];
-        const dist = distanceFn(lat, lon, entry.lat, entry.lon);
-        const withinRadius = dist <= distanceMeters;
-        if (inside ? withinRadius : !withinRadius) {
-          result.add(entry.docId);
-        }
-      }
-      return result;
+      return matching(
+        radiusBoxes(lat, lon, distanceMeters),
+        (entry) => distanceFn(lat, lon, entry.lat, entry.lon) <= distanceMeters,
+        inside
+      );
     },
     polygonQuery(points, inside) {
-      const result = /* @__PURE__ */ new Set();
       const contains = polygonContainment(points);
-      for (let i = 0; i < entries.length; i++) {
-        const entry = entries[i];
-        const withinPolygon = contains(entry.lat, entry.lon);
-        if (inside ? withinPolygon : !withinPolygon) {
-          result.add(entry.docId);
-        }
-      }
-      return result;
+      return matching(polygonBoxes(points), (entry) => contains(entry.lat, entry.lon), inside);
+    },
+    documentsBitset(capacity) {
+      const bits = createBitSet(capacity);
+      for (const entry of entries) bitsetSet(bits, entry.docId);
+      return bits;
     },
     clear() {
       entries.length = 0;
+      byDocument.clear();
+      sorted = true;
     },
     serialize() {
-      return entries.map((e) => ({ ...e }));
+      ensureSorted();
+      return entries.map((entry) => ({ lat: entry.lat, lon: entry.lon, docId: entry.docId }));
     },
     deserialize(data) {
-      entries.length = 0;
-      for (const entry of data) {
-        entries.push({ lat: entry.lat, lon: entry.lon, docId: entry.docId });
-      }
+      index.clear();
+      for (const entry of data) index.insert(entry.docId, entry.lat, entry.lon);
     }
   };
+  return index;
 }
 
 // src/core/field-index/boolean.ts
@@ -4790,9 +5170,90 @@ function createBooleanIndex() {
   };
 }
 
+// src/core/field-index/affixes.ts
+function compareUnits(left, right) {
+  if (left < right) return -1;
+  return left > right ? 1 : 0;
+}
+function reversedUnits(value) {
+  let reversed = "";
+  for (let at = value.length - 1; at >= 0; at--) reversed += value[at];
+  return reversed;
+}
+function firstAtOrAfter2(sorted, key) {
+  let lo = 0;
+  let hi = sorted.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (sorted[mid] < key) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function settledColumn(column, holds) {
+  const { keys, values } = column;
+  const order = [];
+  for (let at = 0; at < keys.length; at++) if (holds(values[at])) order.push(at);
+  order.sort((left, right) => compareUnits(keys[left], keys[right]) || compareUnits(values[left], values[right]));
+  const settled2 = { keys: [], values: [] };
+  for (const at of order) {
+    const last = settled2.values.length - 1;
+    if (last >= 0 && settled2.keys[last] === keys[at] && settled2.values[last] === values[at]) continue;
+    settled2.keys.push(keys[at]);
+    settled2.values.push(values[at]);
+  }
+  return settled2;
+}
+var ValueAffixes = class {
+  constructor(holds, values) {
+    this.holds = holds;
+    for (const value of values) this.add(value);
+  }
+  forward = { keys: [], values: [] };
+  backward = { keys: [], values: [] };
+  settled = true;
+  add(value) {
+    this.forward.keys.push(value);
+    this.forward.values.push(value);
+    this.backward.keys.push(reversedUnits(value));
+    this.backward.values.push(value);
+    this.settled = false;
+  }
+  forget() {
+    this.settled = false;
+  }
+  withPrefix(prefix) {
+    this.settle();
+    return this.matching(this.forward, prefix);
+  }
+  withSuffix(suffix) {
+    this.settle();
+    return this.matching(this.backward, reversedUnits(suffix));
+  }
+  settle() {
+    if (this.settled) return;
+    this.forward = settledColumn(this.forward, this.holds);
+    this.backward = settledColumn(this.backward, this.holds);
+    this.settled = true;
+  }
+  matching(column, start) {
+    const found = [];
+    for (let at = firstAtOrAfter2(column.keys, start); at < column.keys.length; at++) {
+      if (!column.keys[at].startsWith(start)) break;
+      found.push(column.values[at]);
+    }
+    return found;
+  }
+};
+
 // src/core/field-index/enum.ts
 function createEnumIndex() {
   const valueMap = /* @__PURE__ */ new Map();
+  let affixes = null;
+  function affixesOf() {
+    affixes ??= new ValueAffixes((value) => valueMap.has(value), valueMap.keys());
+    return affixes;
+  }
   function allDocs() {
     const result = /* @__PURE__ */ new Set();
     for (const docSet of valueMap.values()) {
@@ -4806,6 +5267,7 @@ function createEnumIndex() {
       if (!docSet) {
         docSet = /* @__PURE__ */ new Set();
         valueMap.set(value, docSet);
+        affixes?.add(value);
       }
       docSet.add(internalId);
     },
@@ -4813,7 +5275,15 @@ function createEnumIndex() {
       const docSet = valueMap.get(value);
       if (!docSet) return;
       docSet.delete(internalId);
-      if (docSet.size === 0) valueMap.delete(value);
+      if (docSet.size > 0) return;
+      valueMap.delete(value);
+      affixes?.forget();
+    },
+    queryPrefixBitset(prefix, capacity) {
+      return this.queryInBitset(affixesOf().withPrefix(prefix), capacity);
+    },
+    querySuffixBitset(suffix, capacity) {
+      return this.queryInBitset(affixesOf().withSuffix(suffix), capacity);
     },
     queryEq(value) {
       const docSet = valueMap.get(value);
@@ -4889,6 +5359,7 @@ function createEnumIndex() {
     },
     clear() {
       valueMap.clear();
+      affixes = null;
     },
     serialize() {
       const result = /* @__PURE__ */ Object.create(null);
@@ -4899,6 +5370,7 @@ function createEnumIndex() {
     },
     deserialize(data) {
       valueMap.clear();
+      affixes = null;
       for (const value of Object.keys(data)) {
         valueMap.set(value, new Set(data[value]));
       }
@@ -5080,6 +5552,44 @@ function createNumericIndex() {
   };
 }
 
+// src/core/partition/value-sizes.ts
+function keepsValueSize(base) {
+  return base === "string" || base === "verbatim" || base.endsWith("[]");
+}
+function valueSizeOf(value) {
+  if (Array.isArray(value)) return value.length;
+  return value === "" ? 0 : 1;
+}
+function sizeIndexOf(indexes, fieldPath) {
+  let index = indexes.get(fieldPath);
+  if (index === void 0) {
+    index = createNumericIndex();
+    indexes.set(fieldPath, index);
+  }
+  return index;
+}
+function recordValueSize(indexes, internalId, fieldPath, base, value) {
+  if (value === void 0 || value === null || !keepsValueSize(base)) return;
+  sizeIndexOf(indexes, fieldPath).insert(internalId, valueSizeOf(value));
+}
+function forgetValueSize(indexes, internalId, fieldPath, base, value) {
+  if (value === void 0 || value === null || !keepsValueSize(base)) return;
+  indexes.get(fieldPath)?.remove(internalId, valueSizeOf(value));
+}
+function rebuildSizeIndexes(state, schema) {
+  state.sizeIndexes.clear();
+  const fields = schemaFieldsOf(schema).filter((field) => keepsValueSize(field.base));
+  if (fields.length === 0) return;
+  for (const [docId, stored] of state.docStore.all()) {
+    const internalId = state.docStore.getInternalId(docId);
+    if (internalId === void 0) continue;
+    for (const { path, base } of fields) {
+      const value = getNestedValue(stored.fields, path);
+      recordValueSize(state.sizeIndexes, internalId, path, base, value);
+    }
+  }
+}
+
 // src/core/partition/indexing.ts
 function ensureFieldIndex(state, fieldPath, base) {
   if ((base === "number" || base === "number[]") && !state.numericIndexes.has(fieldPath)) {
@@ -5218,10 +5728,12 @@ function indexDocument(state, docId, document2, fields, language, options) {
   const fieldLengths = {};
   const tokensByField = {};
   const internalId = resolveInternalId(state, docId);
-  for (const { path: fieldPath, base } of fields) {
+  for (const { path: fieldPath, base, pattern } of fields) {
     const value = getNestedValue(document2, fieldPath);
     if (value === void 0 || value === null) continue;
+    recordValueSize(state.sizeIndexes, internalId, fieldPath, base, value);
     ensureFieldIndex(state, fieldPath, base);
+    if (pattern) patternIndexOf(state.patternIndexes, fieldPath).add(internalId, value);
     if (base === "string") {
       indexStringField(state, internalId, fieldPath, value, language, options, fieldLengths, tokensByField);
     } else if (base === "number") {
@@ -5265,9 +5777,11 @@ function removeFromIndexes(state, docId, storedDoc, schemaFields, language, opti
   const fields = storedDoc.fields;
   const internalId = resolveInternalId(state, docId);
   const opts = tokenizeOptions(options);
-  for (const { path: fieldPath, base } of schemaFields) {
+  for (const { path: fieldPath, base, pattern } of schemaFields) {
     const value = getNestedValue(fields, fieldPath);
     if (value === void 0 || value === null) continue;
+    forgetValueSize(state.sizeIndexes, internalId, fieldPath, base, value);
+    if (pattern) state.patternIndexes.get(fieldPath)?.remove(internalId, value);
     if (base === "string") {
       const result = tokenize(value, language, opts);
       fieldLengths[fieldPath] = result.tokens.length;
@@ -5339,16 +5853,24 @@ function resolveInternalId2(state, docId) {
 }
 function updateFieldIndexOnly(state, docId, oldFields, newDoc, fields) {
   const internalId = resolveInternalId2(state, docId);
-  for (const { path: fieldPath, base: fieldType } of fields) {
+  for (const { path: fieldPath, base: fieldType, pattern } of fields) {
     if (isWordIndexedBase(fieldType)) continue;
     const oldVal = getNestedValue(oldFields, fieldPath);
     const newVal = getNestedValue(newDoc, fieldPath);
     if (oldVal === newVal) continue;
     if (oldVal !== void 0 && oldVal !== null && newVal !== void 0 && newVal !== null && typeof oldVal === typeof newVal && JSON.stringify(oldVal) === JSON.stringify(newVal))
       continue;
+    forgetValueSize(state.sizeIndexes, internalId, fieldPath, fieldType, oldVal);
+    recordValueSize(state.sizeIndexes, internalId, fieldPath, fieldType, newVal);
     if (newVal !== void 0 && newVal !== null) {
       ensureFieldIndex(state, fieldPath, fieldType);
     }
+    if (pattern) {
+      if (oldVal !== void 0 && oldVal !== null) state.patternIndexes.get(fieldPath)?.remove(internalId, oldVal);
+      if (newVal !== void 0 && newVal !== null) {
+        patternIndexOf(state.patternIndexes, fieldPath).add(internalId, newVal);
+      }
+    }
     if (fieldType === "number") {
       const numIdx = state.numericIndexes.get(fieldPath);
       if (numIdx) {
@@ -5410,27 +5932,224 @@ function updateFieldIndexOnly(state, docId, oldFields, newDoc, fields) {
   }
 }
 
-// src/filters/combinators.ts
-function applyAndBitset(bitsets) {
-  if (bitsets.length === 0) return new Uint32Array(0);
-  if (bitsets.length === 1) return bitsets[0];
-  let result = bitsets[0];
-  for (let i = 1; i < bitsets.length; i++) {
-    result = bitsetAnd(result, bitsets[i]);
+// 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/pattern-tests.ts
+function excluding(context, fieldPath, excluded) {
+  const universe = bitsetAnd(context.presentBitset(fieldPath), context.allDocIdsBitset);
+  return bitsetAnd(universe, bitsetNot(excluded, context.capacity));
+}
+function textsOf(operand) {
+  const texts = /* @__PURE__ */ new Set();
+  if (!Array.isArray(operand)) return texts;
+  for (const text of operand) if (typeof text === "string") texts.add(text);
+  return texts;
+}
+function evaluatePatternTests(fieldPath, filter, context, bitsets) {
+  const caseFold = filter.caseFold === true;
+  const matching = (operator, texts) => {
+    const into = createBitSet(context.capacity);
+    for (const text of texts) context.matchPattern(fieldPath, operator, text, caseFold, into);
+    return into;
+  };
+  if (typeof filter.eq === "string") bitsets.push(matching("eq", [filter.eq]));
+  if (typeof filter.ne === "string") bitsets.push(excluding(context, fieldPath, matching("eq", [filter.ne])));
+  if (filter.in !== void 0) bitsets.push(matching("eq", textsOf(filter.in)));
+  if (filter.nin !== void 0) bitsets.push(excluding(context, fieldPath, matching("eq", textsOf(filter.nin))));
+  if (typeof filter.startsWith === "string") bitsets.push(matching("startsWith", [filter.startsWith]));
+  if (typeof filter.endsWith === "string") bitsets.push(matching("endsWith", [filter.endsWith]));
+  if (typeof filter.contains === "string") bitsets.push(matching("contains", [filter.contains]));
+}
+
+// src/filters/field-tests.ts
+var COMPARISON_OPERATORS = ["eq", "ne", "gt", "gte", "lt", "lte", "between"];
+var TEXT_RANGE_OPERATORS = ["gt", "gte", "lt", "lte"];
+var FieldBits = class {
+  constructor(context, fieldPath) {
+    this.context = context;
+    this.fieldPath = fieldPath;
   }
-  return result;
+  none() {
+    return createBitSet(this.context.capacity);
+  }
+  present() {
+    return this.context.presentBitset(this.fieldPath);
+  }
+  holdingSomething() {
+    const empty = this.context.sizeIndex(this.fieldPath)?.queryEqBitset(0, this.context.capacity);
+    return empty === void 0 ? this.present() : this.without(this.present(), empty);
+  }
+  without(from, removed) {
+    const kept = from.slice();
+    bitsetAndNotInto(kept, removed);
+    return kept;
+  }
+  complement(bits) {
+    return this.without(this.context.allDocIdsBitset, bits);
+  }
+};
+function comparisonBits(index, operator, operand, bits, capacity) {
+  if (operator === "between") {
+    const [low, high] = operand;
+    return index?.queryBetweenBitset(low, high, capacity) ?? bits.none();
+  }
+  const value = operand;
+  if (operator === "ne") return bits.without(bits.present(), index?.queryEqBitset(value, capacity) ?? bits.none());
+  if (index === void 0) return bits.none();
+  if (operator === "eq") return index.queryEqBitset(value, capacity);
+  if (operator === "gt") return index.queryGtBitset(value, capacity);
+  if (operator === "gte") return index.queryGteBitset(value, capacity);
+  if (operator === "lt") return index.queryLtBitset(value, capacity);
+  return index.queryLteBitset(value, capacity);
+}
+function elementBits(context, fieldPath, parsed, value) {
+  const { capacity } = context;
+  if (parsed.pattern) {
+    const matches = createBitSet(capacity);
+    context.matchPattern(fieldPath, "eq", value, false, matches);
+    return matches;
+  }
+  if (typeof value === "number")
+    return context.numericIndex(fieldPath)?.queryEqBitset(value, capacity) ?? createBitSet(capacity);
+  if (typeof value === "boolean")
+    return context.booleanIndex(fieldPath)?.queryEqBitset(value, capacity) ?? createBitSet(capacity);
+  return context.enumIndex(fieldPath)?.queryEqBitset(value, capacity) ?? createBitSet(capacity);
 }
-function applyOrBitset(bitsets) {
-  if (bitsets.length === 0) return new Uint32Array(0);
-  if (bitsets.length === 1) return bitsets[0];
-  let result = bitsets[0];
-  for (let i = 1; i < bitsets.length; i++) {
-    result = bitsetOr(result, bitsets[i]);
+function anyElementBits(context, fieldPath, parsed, values) {
+  const { capacity } = context;
+  const union = createBitSet(capacity);
+  if (parsed.pattern) {
+    for (const value of values) context.matchPattern(fieldPath, "eq", value, false, union);
+    return union;
   }
-  return result;
+  if (parsed.base === "enum[]") {
+    return context.enumIndex(fieldPath)?.queryInBitset(values, capacity) ?? union;
+  }
+  const numbers = context.numericIndex(fieldPath);
+  const booleans = context.booleanIndex(fieldPath);
+  for (const value of values) {
+    if (typeof value === "number") for (const docId of numbers?.queryEq(value) ?? []) bitsetSet(union, docId);
+    if (typeof value === "boolean") for (const docId of booleans?.queryEq(value) ?? []) bitsetSet(union, docId);
+  }
+  return union;
+}
+function distinctScalars(values) {
+  return [...new Set(values)];
+}
+function narrowByElements(fieldPath, f, parsed, context, bits, narrow) {
+  if (f.matchesAny !== void 0) narrow(anyElementBits(context, fieldPath, parsed, distinctScalars(f.matchesAny)));
+  if (f.containsAll !== void 0) {
+    const all = bits.present().slice();
+    for (const value of distinctScalars(f.containsAll)) {
+      if (bitsetIsEmpty(all)) break;
+      bitsetAndInto(all, elementBits(context, fieldPath, parsed, value));
+    }
+    narrow(all);
+  }
+  if (f.size !== void 0) {
+    const sizes = context.sizeIndex(fieldPath);
+    const comparison = f.size;
+    for (const operator of COMPARISON_OPERATORS) {
+      if (comparison[operator] === void 0) continue;
+      narrow(comparisonBits(sizes, operator, comparison[operator], bits, context.capacity));
+    }
+  }
+}
+function narrowByValue(fieldPath, f, parsed, context, bits, narrow) {
+  const { capacity } = context;
+  const base = parsed.base;
+  if (base === "number" || base === "number[]") {
+    const index = context.numericIndex(fieldPath);
+    for (const operator of COMPARISON_OPERATORS) {
+      const operand = f[operator];
+      if (operand === void 0 || typeof operand === "string") continue;
+      if (operator === "between" && typeof operand[0] === "string") continue;
+      narrow(comparisonBits(index, operator, operand, bits, capacity));
+    }
+    return;
+  }
+  if (base === "boolean" || base === "boolean[]") {
+    const index = context.booleanIndex(fieldPath);
+    const equal = (value) => index?.queryEqBitset(value, capacity) ?? bits.none();
+    if (typeof f.eq === "boolean") narrow(equal(f.eq));
+    if (typeof f.ne === "boolean") narrow(bits.without(bits.present(), equal(f.ne)));
+    return;
+  }
+  if (base === "enum" || base === "enum[]") {
+    const index = context.enumIndex(fieldPath);
+    const equal = (value) => index?.queryEqBitset(value, capacity) ?? bits.none();
+    const anyOf = (values) => index?.queryInBitset(values, capacity) ?? bits.none();
+    if (typeof f.eq === "string") narrow(equal(f.eq));
+    if (typeof f.ne === "string") narrow(bits.without(bits.present(), equal(f.ne)));
+    if (Array.isArray(f.in)) narrow(anyOf(f.in));
+    if (Array.isArray(f.nin)) narrow(bits.without(bits.present(), anyOf(f.nin)));
+    if (typeof f.startsWith === "string") narrow(index?.queryPrefixBitset(f.startsWith, capacity) ?? bits.none());
+    if (typeof f.endsWith === "string") narrow(index?.querySuffixBitset(f.endsWith, capacity) ?? bits.none());
+  }
+}
+function narrowByLocation(fieldPath, f, context, narrow) {
+  const index = context.geoIndex(fieldPath);
+  if (f.radius !== void 0) {
+    const circle = f.radius;
+    const found = index?.radiusQuery(
+      circle.lat,
+      circle.lon,
+      circle.distance * GEO_UNIT_METRES[circle.unit],
+      circle.inside ?? true,
+      circle.highPrecision ?? false
+    );
+    narrow(bitsetFromSet(found ?? /* @__PURE__ */ new Set(), context.capacity));
+  }
+  if (f.polygon !== void 0) {
+    const polygon = f.polygon;
+    narrow(bitsetFromSet(index?.polygonQuery(polygon.points, polygon.inside ?? true) ?? /* @__PURE__ */ new Set(), context.capacity));
+  }
+}
+function narrowByPresence(f, bits, narrow) {
+  if (typeof f.exists === "boolean") narrow(f.exists ? bits.present() : bits.complement(bits.present()));
+  if (typeof f.notExists === "boolean") narrow(f.notExists ? bits.complement(bits.present()) : bits.present());
+  if (typeof f.isNotEmpty === "boolean") {
+    const holding = bits.holdingSomething();
+    narrow(f.isNotEmpty ? holding : bits.complement(holding));
+  }
+  if (typeof f.isEmpty === "boolean") {
+    const holding = bits.holdingSomething();
+    narrow(f.isEmpty ? bits.complement(holding) : holding);
+  }
+}
+function textBoundsOf(operator, bound) {
+  if (operator === "gt" || operator === "gte") {
+    return { lower: bound, upper: null, lowerInclusive: operator === "gte", upperInclusive: false };
+  }
+  return { lower: null, upper: bound, upperInclusive: operator === "lte", lowerInclusive: false };
 }
-function applyNotBitset(excluded, capacity) {
-  return bitsetNot(excluded, capacity);
+function narrowByTextRange(fieldPath, f, context, narrow) {
+  for (const operator of TEXT_RANGE_OPERATORS) {
+    const bound = f[operator];
+    if (typeof bound === "string") narrow(context.textRangeBitset(fieldPath, textBoundsOf(operator, bound)));
+  }
+  if (!Array.isArray(f.between)) return;
+  const [low, high] = f.between;
+  if (typeof low !== "string" || typeof high !== "string") return;
+  narrow(context.textRangeBitset(fieldPath, { lower: low, lowerInclusive: true, upper: high, upperInclusive: true }));
+}
+function narrowByFieldTests(fieldPath, f, parsed, context, narrow) {
+  const bits = new FieldBits(context, fieldPath);
+  narrowByPresence(f, bits, narrow);
+  narrowByLocation(fieldPath, f, context, narrow);
+  narrowByTextRange(fieldPath, f, context, narrow);
+  if (parsed.pattern) {
+    const patternBits = [];
+    evaluatePatternTests(fieldPath, f, context, patternBits);
+    for (const matched of patternBits) narrow(matched);
+  } else {
+    narrowByValue(fieldPath, f, parsed, context, bits, narrow);
+  }
+  narrowByElements(fieldPath, f, parsed, context, bits, narrow);
 }
 
 // src/filters/keys.ts
@@ -5447,6 +6166,8 @@ var FIELD_FILTER_OPERATORS = [
   "nin",
   "startsWith",
   "endsWith",
+  "contains",
+  "caseFold",
   "containsAll",
   "matchesAny",
   "size",
@@ -5458,14 +6179,7 @@ var FIELD_FILTER_OPERATORS = [
   "polygon"
 ];
 
-// 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"];
+// src/filters/operands/checks.ts
 function operandKindOf(type) {
   if (type === void 0) return void 0;
   if (type === "number" || type === "number[]") return "number";
@@ -5483,6 +6197,9 @@ function kindOfValue(value) {
   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 });
 }
@@ -5495,40 +6212,247 @@ function requireFieldKind(fieldPath, operator, type, accepted) {
     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}"`;
+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/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;
+  if (circle === null || typeof circle !== "object") {
+    invalid(`"radius" on field "${fieldPath}" must be an object`, fieldPath, "radius");
+  }
+  for (const key of ["lat", "lon", "distance"]) {
+    if (!isFiniteNumber(circle[key])) {
+      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)}`,
+      fieldPath,
+      "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(
-    `The engine applies "${operator}" with a text bound to a "string" or "verbatim" field whose type includes "sortable", but ${declared}`,
+    `"${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 requireRadius(fieldPath, radius) {
-  const circle = radius;
-  if (circle === null || typeof circle !== "object") {
-    invalid(`"radius" on field "${fieldPath}" must be an object`, fieldPath, "radius");
-  }
-  for (const key of ["lat", "lon", "distance"]) {
-    if (!isFiniteNumber(circle[key])) {
-      invalid(`"radius.${key}" on field "${fieldPath}" must be a finite number`, fieldPath, "radius");
-    }
+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 (circle.distance < 0) {
+  if (caseFold && foldedCodePointCount(text) > MAX_PATTERN_POSITIONS) {
     invalid(
-      `"radius.distance" on field "${fieldPath}" must be zero or more, and this filter sets ${String(circle.distance)}`,
+      `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,
-      "radius"
+      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,
@@ -5536,34 +6460,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;
@@ -5576,22 +6480,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") {
@@ -5617,247 +6522,74 @@ 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");
-  }
-  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);
-  }
-}
-
-// src/filters/operators/shared.ts
-var METERS_PER_KM = 1e3;
-var METERS_PER_MI = 1609.344;
-function convertToMeters(distance, unit) {
-  if (unit === "km") return distance * METERS_PER_KM;
-  if (unit === "mi") return distance * METERS_PER_MI;
-  if (unit === "m") return distance;
-  throw new NarsilError(
-    ErrorCodes.SEARCH_INVALID_FILTER,
-    `The engine measures a radius in "km", "mi", or "m", and "${String(unit)}" is none of them`,
-    { unit: String(unit) }
-  );
-}
-function matchesNumericComparison(value, filter) {
-  if (filter.eq !== void 0 && value !== filter.eq) return false;
-  if (filter.ne !== void 0 && value === filter.ne) return false;
-  if (filter.gt !== void 0 && !(value > filter.gt)) return false;
-  if (filter.lt !== void 0 && !(value < filter.lt)) return false;
-  if (filter.gte !== void 0 && !(value >= filter.gte)) return false;
-  if (filter.lte !== void 0 && !(value <= filter.lte)) return false;
-  if (filter.between !== void 0 && !(value >= filter.between[0] && value <= filter.between[1])) return false;
-  return true;
-}
-function holdsValue(stored, value) {
-  return Array.isArray(stored) ? stored.includes(value) : stored === value;
-}
-function lacksValue(stored, value) {
-  if (stored === void 0 || stored === null) return false;
-  return Array.isArray(stored) ? !stored.includes(value) : stored !== value;
-}
-function isStringIn(values) {
-  return (element) => typeof element === "string" && values.has(element);
-}
-function holdsStringIn(stored, values) {
-  return Array.isArray(stored) ? stored.some(isStringIn(values)) : isStringIn(values)(stored);
-}
-function holdsNoStringIn(stored, values) {
-  if (Array.isArray(stored)) return !stored.some(isStringIn(values));
-  return typeof stored === "string" && !values.has(stored);
-}
-function holdsStringWhere(stored, test) {
-  const matches = (element) => typeof element === "string" && test(element);
-  return Array.isArray(stored) ? stored.some(matches) : matches(stored);
-}
-
-// src/filters/operators/bitset.ts
-function resolveBitset(bs) {
-  return typeof bs === "function" ? bs() : bs;
-}
-function scanToBitset(docIds, capacity, getValue, predicate) {
-  const resolved = resolveBitset(docIds);
-  const result = createBitSet(capacity);
-  for (let wi = 0; wi < resolved.length; wi++) {
-    let word = resolved[wi];
-    if (word === 0) continue;
-    const base = wi << 5;
-    while (word !== 0) {
-      const tz = Math.clz32(word & -word) ^ 31;
-      const id = base + tz;
-      if (predicate(getValue(id))) {
-        bitsetSet(result, id);
-      }
-      word &= word - 1;
-    }
-  }
-  return result;
-}
-function applyEqBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric" && typeof value === "number") {
-    return fieldIndex.index.eqBitset(value, capacity);
-  }
-  if (fieldIndex?.type === "boolean" && typeof value === "boolean") {
-    return value ? fieldIndex.index.getTrueBitset(capacity) : fieldIndex.index.getFalseBitset(capacity);
-  }
-  if (fieldIndex?.type === "enum" && typeof value === "string") {
-    return fieldIndex.index.getDocIdsBitset(value, capacity);
-  }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsValue(v, value));
-}
-function applyNeBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric" && typeof value === "number") {
-    const all = fieldIndex.index.allDocIdsBitset(capacity);
-    const eq = fieldIndex.index.eqBitset(value, capacity);
-    return bitsetAnd(all, bitsetNot(eq, capacity));
-  }
-  if (fieldIndex?.type === "boolean" && typeof value === "boolean") {
-    return value ? fieldIndex.index.getFalseBitset(capacity) : fieldIndex.index.getTrueBitset(capacity);
-  }
-  if (fieldIndex?.type === "enum" && typeof value === "string") {
-    const all = fieldIndex.index.allDocIdsBitset(capacity);
-    const eq = fieldIndex.index.getDocIdsBitset(value, capacity);
-    return bitsetAnd(all, bitsetNot(eq, capacity));
-  }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => lacksValue(v, value));
-}
-function applyGtBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric") {
-    return fieldIndex.index.gtBitset(value, capacity);
-  }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v > value);
-}
-function applyLtBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric") {
-    return fieldIndex.index.ltBitset(value, capacity);
-  }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v < value);
-}
-function applyGteBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric") {
-    return fieldIndex.index.gteBitset(value, capacity);
-  }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v >= value);
-}
-function applyLteBitset(value, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric") {
-    return fieldIndex.index.lteBitset(value, capacity);
-  }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v <= value);
-}
-function applyBetweenBitset(range, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "numeric") {
-    return fieldIndex.index.betweenBitset(range[0], range[1], capacity);
+  for (const operator of GEO_OPERATORS) {
+    if (filter[operator] !== void 0) requireFieldKind(fieldPath, operator, type, ["geopoint"]);
   }
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => typeof v === "number" && v >= range[0] && v <= range[1]);
 }
-function applyInBitset(values, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "enum") {
-    return fieldIndex.index.getDocIdsInBitset(values, capacity);
+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 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);
   }
-  const valSet = new Set(values);
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsStringIn(v, valSet));
-}
-function applyNinBitset(values, allDocsBitset, capacity, getValue, fieldIndex) {
-  if (fieldIndex?.type === "enum") {
-    const all = fieldIndex.index.allDocIdsBitset(capacity);
-    const matched = fieldIndex.index.getDocIdsInBitset(values, capacity);
-    return bitsetAnd(all, bitsetNot(matched, capacity));
+  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);
   }
-  const valSet = new Set(values);
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsNoStringIn(v, valSet));
-}
-function applyStartsWithBitset(prefix, allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsStringWhere(v, (text) => text.startsWith(prefix)));
-}
-function applyEndsWithBitset(suffix, allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => holdsStringWhere(v, (text) => text.endsWith(suffix)));
-}
-function applyContainsAllBitset(values, allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
-    if (!Array.isArray(v)) return false;
-    const arr = v;
-    for (const val of values) {
-      if (!arr.includes(val)) return false;
-    }
-    return true;
-  });
-}
-function applyMatchesAnyBitset(values, allDocsBitset, capacity, getValue) {
-  const valSet = new Set(values);
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
-    if (!Array.isArray(v)) return false;
-    for (const item of v) {
-      if (valSet.has(item)) return true;
-    }
-    return false;
-  });
-}
-function applySizeBitset(sizeFilter, allDocsBitset, capacity, getValue) {
-  return scanToBitset(
-    allDocsBitset,
-    capacity,
-    getValue,
-    (v) => Array.isArray(v) && matchesNumericComparison(v.length, sizeFilter)
-  );
-}
-function applyExistsBitset(allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v !== void 0 && v !== null);
-}
-function applyNotExistsBitset(allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => v === void 0 || v === null);
-}
-function applyIsEmptyBitset(allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
-    if (v === void 0 || v === null) return true;
-    if (typeof v === "string" && v === "") return true;
-    if (Array.isArray(v) && v.length === 0) return true;
-    return false;
-  });
-}
-function applyIsNotEmptyBitset(allDocsBitset, capacity, getValue) {
-  return scanToBitset(allDocsBitset, capacity, getValue, (v) => {
-    if (v === void 0 || v === null) return false;
-    if (typeof v === "string" && v === "") return false;
-    if (Array.isArray(v) && v.length === 0) return false;
-    return true;
-  });
-}
-function applyGeoRadiusBitset(filter, geoIndex, capacity) {
-  const distanceMeters = convertToMeters(filter.distance, filter.unit);
-  const setResult = geoIndex.radiusQuery(
-    filter.lat,
-    filter.lon,
-    distanceMeters,
-    filter.inside ?? true,
-    filter.highPrecision ?? false
-  );
-  return bitsetFromSet(setResult, capacity);
+  if (not !== void 0) requireValidExpression(not, walk, depth + 1);
 }
-function applyGeoPolygonBitset(filter, geoIndex, capacity) {
-  requirePolygonRing(filter.points);
-  const setResult = geoIndex.polygonQuery(filter.points, filter.inside ?? true);
-  return bitsetFromSet(setResult, capacity);
+function requireValidFilter(expression, fieldTypes) {
+  if (expression === void 0 || expression === null) return;
+  requireValidExpression(expression, { fieldTypes, tests: 0 }, 0);
 }
 
 // src/filters/evaluator.ts
-var UNBOUNDED = { lower: null, upper: null };
-function textBoundsOf(operator, bound) {
-  if (operator === "gt" || operator === "gte") {
-    return { ...UNBOUNDED, lower: bound, lowerInclusive: operator === "gte", upperInclusive: false };
-  }
-  return { ...UNBOUNDED, upper: bound, upperInclusive: operator === "lte", lowerInclusive: false };
-}
-var TEXT_RANGE_OPERATORS = ["gt", "gte", "lt", "lte"];
 var EXPRESSION_KEYS = new Set(FILTER_EXPRESSION_KEYS);
 var OPERATOR_KEYS = new Set(FIELD_FILTER_OPERATORS);
 function requireKnownKeys2(value, known, describe) {
@@ -5867,160 +6599,66 @@ function requireKnownKeys2(value, known, describe) {
     }
   }
 }
+var Narrowing = class {
+  bits = null;
+  narrow = (matched) => {
+    if (this.bits === null) this.bits = matched.slice();
+    else bitsetAndInto(this.bits, matched);
+  };
+  value(universe) {
+    return this.bits ?? universe().slice();
+  }
+};
+function narrowByField(fieldPath, filter, context, narrow) {
+  requireKnownKeys2(
+    filter,
+    OPERATOR_KEYS,
+    (key) => `Field "${fieldPath}" is tested with "${key}", which is no filter operator`
+  );
+  const type = context.fieldTypes[fieldPath];
+  const parsed = parsedTypeOf(type);
+  if (type === void 0 || parsed === void 0) throw undeclaredFilterField(fieldPath);
+  const f = filter;
+  requireValidOperands(fieldPath, f, type);
+  narrowByFieldTests(fieldPath, f, parsed, context, narrow.narrow);
+}
 function evaluateFilters(expression, context) {
   requireKnownKeys2(
     expression,
     EXPRESSION_KEYS,
     (key) => `A filter expression takes "fields", "and", "or", and "not", and "${key}" is none of them. A per-field test such as { ${key}: { eq: ... } } belongs under "fields"`
   );
-  const bitsets = [];
+  const narrowing = new Narrowing();
   if (expression.fields) {
     for (const [fieldPath, filter] of Object.entries(expression.fields)) {
-      bitsets.push(evaluateFieldFilter(fieldPath, filter, context));
+      narrowByField(fieldPath, filter, context, narrowing);
     }
   }
   if (expression.and?.length) {
-    const andBitsets = expression.and.map((expr) => evaluateFilters(expr, context));
-    bitsets.push(applyAndBitset(andBitsets));
+    for (const nested of expression.and) narrowing.narrow(evaluateFilters(nested, context));
   }
   if (expression.or?.length) {
-    const orBitsets = expression.or.map((expr) => evaluateFilters(expr, context));
-    bitsets.push(applyOrBitset(orBitsets));
+    const union = createBitSet(context.capacity);
+    for (const nested of expression.or) bitsetOrInto(union, evaluateFilters(nested, context));
+    narrowing.narrow(union);
   }
   if (expression.not) {
     const excluded = evaluateFilters(expression.not, context);
-    const universe = context.allDocIdsBitset;
-    bitsets.push(applyAndBitset([universe, applyNotBitset(excluded, context.capacity)]));
-  }
-  if (bitsets.length === 0) return context.allDocIdsBitset;
-  if (bitsets.length === 1) return bitsets[0];
-  return applyAndBitset(bitsets);
-}
-function evaluateFieldFilter(fieldPath, filter, context) {
-  requireKnownKeys2(
-    filter,
-    OPERATOR_KEYS,
-    (key) => `Field "${fieldPath}" is tested with "${key}", which is no filter operator`
-  );
-  const f = filter;
-  requireValidOperands(fieldPath, f, context.fieldTypes[fieldPath]);
-  const fieldIndex = context.fieldIndexes[fieldPath];
-  const getValue = (internalId) => context.getFieldValue(internalId, fieldPath);
-  const bitsets = [];
-  const { capacity } = context;
-  let allDocsBitset = null;
-  const getAllDocsBitset = () => {
-    if (allDocsBitset === null) {
-      allDocsBitset = context.allDocIdsBitset;
-    }
-    return allDocsBitset;
-  };
-  if ("radius" in f && f.radius) {
-    const geoIndex = resolveGeoIndex(fieldPath, fieldIndex);
-    bitsets.push(applyGeoRadiusBitset(filter.radius, geoIndex, capacity));
+    const kept = context.allDocIdsBitset.slice();
+    bitsetAndNotInto(kept, excluded);
+    narrowing.narrow(kept);
   }
-  if ("polygon" in f && f.polygon) {
-    const geoIndex = resolveGeoIndex(fieldPath, fieldIndex);
-    bitsets.push(applyGeoPolygonBitset(filter.polygon, geoIndex, capacity));
-  }
-  if ("eq" in f && f.eq !== void 0) {
-    bitsets.push(applyEqBitset(f.eq, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("ne" in f && f.ne !== void 0) {
-    bitsets.push(applyNeBitset(f.ne, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  for (const operator of TEXT_RANGE_OPERATORS) {
-    const bound = f[operator];
-    if (typeof bound === "string") bitsets.push(context.textRangeBitset(fieldPath, textBoundsOf(operator, bound)));
-  }
-  if (typeof f.gt === "number") {
-    bitsets.push(applyGtBitset(f.gt, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if (typeof f.lt === "number") {
-    bitsets.push(applyLtBitset(f.lt, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if (typeof f.gte === "number") {
-    bitsets.push(applyGteBitset(f.gte, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if (typeof f.lte === "number") {
-    bitsets.push(applyLteBitset(f.lte, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if (Array.isArray(f.between)) {
-    const [low, high] = f.between;
-    if (typeof low === "string" && typeof high === "string") {
-      bitsets.push(
-        context.textRangeBitset(fieldPath, { lower: low, lowerInclusive: true, upper: high, upperInclusive: true })
-      );
-    } else {
-      bitsets.push(
-        applyBetweenBitset([low, high], getAllDocsBitset, capacity, getValue, fieldIndex)
-      );
-    }
-  }
-  if ("in" in f && f.in !== void 0) {
-    bitsets.push(applyInBitset(f.in, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("nin" in f && f.nin !== void 0) {
-    bitsets.push(applyNinBitset(f.nin, getAllDocsBitset, capacity, getValue, fieldIndex));
-  }
-  if ("startsWith" in f && f.startsWith !== void 0) {
-    bitsets.push(applyStartsWithBitset(f.startsWith, getAllDocsBitset, capacity, getValue));
-  }
-  if ("endsWith" in f && f.endsWith !== void 0) {
-    bitsets.push(applyEndsWithBitset(f.endsWith, getAllDocsBitset, capacity, getValue));
-  }
-  if ("containsAll" in f && f.containsAll !== void 0) {
-    bitsets.push(
-      applyContainsAllBitset(f.containsAll, getAllDocsBitset, capacity, getValue)
-    );
-  }
-  if ("matchesAny" in f && f.matchesAny !== void 0) {
-    bitsets.push(
-      applyMatchesAnyBitset(f.matchesAny, getAllDocsBitset, capacity, getValue)
-    );
-  }
-  if ("size" in f && f.size !== void 0) {
-    bitsets.push(applySizeBitset(f.size, getAllDocsBitset, capacity, getValue));
-  }
-  if ("exists" in f && f.exists !== void 0) {
-    bitsets.push(
-      f.exists ? applyExistsBitset(getAllDocsBitset, capacity, getValue) : applyNotExistsBitset(getAllDocsBitset, capacity, getValue)
-    );
-  }
-  if ("notExists" in f && f.notExists !== void 0) {
-    bitsets.push(
-      f.notExists ? applyNotExistsBitset(getAllDocsBitset, capacity, getValue) : applyExistsBitset(getAllDocsBitset, capacity, getValue)
-    );
-  }
-  if ("isEmpty" in f && f.isEmpty !== void 0) {
-    bitsets.push(
-      f.isEmpty ? applyIsEmptyBitset(getAllDocsBitset, capacity, getValue) : applyIsNotEmptyBitset(getAllDocsBitset, capacity, getValue)
-    );
-  }
-  if ("isNotEmpty" in f && f.isNotEmpty !== void 0) {
-    bitsets.push(
-      f.isNotEmpty ? applyIsNotEmptyBitset(getAllDocsBitset, capacity, getValue) : applyIsEmptyBitset(getAllDocsBitset, capacity, getValue)
-    );
-  }
-  if (bitsets.length === 0) return context.allDocIdsBitset;
-  if (bitsets.length === 1) return bitsets[0];
-  return applyAndBitset(bitsets);
-}
-function resolveGeoIndex(fieldPath, fieldIndex) {
-  if (fieldIndex?.type !== "geopoint") {
-    throw new NarsilError(
-      ErrorCodes.SEARCH_INVALID_FILTER,
-      `Field "${fieldPath}" requires a geopoint index for geo filters`,
-      { fieldPath }
-    );
-  }
-  return fieldIndex.index;
+  return narrowing.value(() => context.allDocIdsBitset);
 }
 
 // src/core/partition/constants.ts
 var TARGET_BLOCK_ENTRIES = 128;
 var PRUNING_REJECTION_SLACK = 1e-12;
 var SCORE_BUFFER_INITIAL_TOUCHED_CAPACITY = 1024;
+var SEGMENT_TOKEN_TABLE_START = 1 << 12;
+var SEGMENT_POSTING_LOG_START = 1 << 14;
+var SEGMENT_POSITION_POOL_START = 1 << 16;
+var SEGMENT_FIELD_SCRATCH_START = 1 << 10;
 var SORT_COLUMN_MINIMUM_REBUILD_THRESHOLD = 1024;
 var SORT_COLUMN_REBUILD_FRACTION_SHIFT = 2;
 
@@ -6637,99 +7275,72 @@ function sortColumnBytes(state) {
 }
 
 // src/core/partition/filters.ts
-var EMPTY_GEO_INDEX = {
-  radiusQuery: () => /* @__PURE__ */ new Set(),
-  polygonQuery: () => /* @__PURE__ */ new Set()
-};
-function buildFilterContext(state, schema) {
+function presentBitsetOf(state, fieldPath, type, capacity) {
+  const base = parsedTypeOf(type)?.base;
+  let present;
+  if (base === "number") present = state.numericIndexes.get(fieldPath)?.getAllDocIdsBitset(capacity);
+  else if (base === "boolean") present = state.booleanIndexes.get(fieldPath)?.getAllDocIdsBitset(capacity);
+  else if (base === "enum") present = state.enumIndexes.get(fieldPath)?.getAllDocIdsBitset(capacity);
+  else if (base === "geopoint") present = state.geoIndexes.get(fieldPath)?.documentsBitset(capacity);
+  else if (base !== void 0 && keepsValueSize(base)) {
+    present = state.sizeIndexes.get(fieldPath)?.getAllDocIdsBitset(capacity);
+  }
+  return present ?? createBitSet(capacity);
+}
+function liveDocumentsBitset(state, capacity) {
+  const bits = createBitSet(capacity);
+  for (const internalId of state.docStore.allInternalIds()) bitsetSet(bits, internalId);
+  return bits;
+}
+function buildFilterContext(state, schema, meter) {
   const flat = getFlatSchema(state, schema);
-  const fieldIndexes = {};
   const capacity = state.docStore.internalIdCapacity();
-  for (const { path: fieldPath, base: fieldType } of schemaFieldsOf(schema)) {
-    if (fieldType === "number" || fieldType === "number[]") {
-      const numIdx = state.numericIndexes.get(fieldPath);
-      if (numIdx) {
-        fieldIndexes[fieldPath] = {
-          type: "numeric",
-          index: {
-            eq: (v) => numIdx.queryEq(v),
-            gt: (v) => numIdx.queryGt(v),
-            gte: (v) => numIdx.queryGte(v),
-            lt: (v) => numIdx.queryLt(v),
-            lte: (v) => numIdx.queryLte(v),
-            between: (min, max) => numIdx.queryBetween(min, max),
-            allDocIds: () => numIdx.getAllDocIds(),
-            eqBitset: (v, cap) => numIdx.queryEqBitset(v, cap),
-            gtBitset: (v, cap) => numIdx.queryGtBitset(v, cap),
-            gteBitset: (v, cap) => numIdx.queryGteBitset(v, cap),
-            ltBitset: (v, cap) => numIdx.queryLtBitset(v, cap),
-            lteBitset: (v, cap) => numIdx.queryLteBitset(v, cap),
-            betweenBitset: (min, max, cap) => numIdx.queryBetweenBitset(min, max, cap),
-            allDocIdsBitset: (cap) => numIdx.getAllDocIdsBitset(cap)
-          }
-        };
-      }
-    } else if (fieldType === "boolean" || fieldType === "boolean[]") {
-      const boolIdx = state.booleanIndexes.get(fieldPath);
-      if (boolIdx) {
-        fieldIndexes[fieldPath] = {
-          type: "boolean",
-          index: {
-            getTrue: () => boolIdx.queryEq(true),
-            getFalse: () => boolIdx.queryEq(false),
-            allDocIds: () => boolIdx.getAllDocIds(),
-            getTrueBitset: (cap) => boolIdx.queryEqBitset(true, cap),
-            getFalseBitset: (cap) => boolIdx.queryEqBitset(false, cap),
-            allDocIdsBitset: (cap) => boolIdx.getAllDocIdsBitset(cap)
-          }
-        };
-      }
-    } else if (fieldType === "enum" || fieldType === "enum[]") {
-      const enumIdx = state.enumIndexes.get(fieldPath);
-      if (enumIdx) {
-        fieldIndexes[fieldPath] = {
-          type: "enum",
-          index: {
-            getDocIds: (v) => enumIdx.queryEq(v),
-            allDocIds: () => enumIdx.getAllDocIds(),
-            getDocIdsBitset: (v, cap) => enumIdx.queryEqBitset(v, cap),
-            getDocIdsInBitset: (values, cap) => enumIdx.queryInBitset(values, cap),
-            allDocIdsBitset: (cap) => enumIdx.getAllDocIdsBitset(cap)
-          }
-        };
-      }
-    } else if (fieldType === "geopoint") {
-      const geoIdx = state.geoIndexes.get(fieldPath);
-      fieldIndexes[fieldPath] = {
-        type: "geopoint",
-        index: geoIdx === void 0 ? EMPTY_GEO_INDEX : geoIdx
-      };
-    }
+  const patternFields = /* @__PURE__ */ new Set();
+  for (const { path: fieldPath, pattern } of schemaFieldsOf(schema)) {
+    if (pattern) patternFields.add(fieldPath);
   }
-  let cachedAllDocIds = null;
+  const getFieldValue = (internalId, fieldPath) => getFieldValueByInternalId(state.docStore, internalId, fieldPath);
   let cachedAllDocIdsBitset = null;
+  const cachedPresentBitsets = /* @__PURE__ */ new Map();
   return {
     fieldTypes: flat,
-    fieldIndexes,
-    getFieldValue: (internalId, fieldPath) => getFieldValueByInternalId(state.docStore, internalId, fieldPath),
+    numericIndex: (fieldPath) => state.numericIndexes.get(fieldPath),
+    booleanIndex: (fieldPath) => state.booleanIndexes.get(fieldPath),
+    enumIndex: (fieldPath) => state.enumIndexes.get(fieldPath),
+    geoIndex: (fieldPath) => state.geoIndexes.get(fieldPath),
+    sizeIndex: (fieldPath) => state.sizeIndexes.get(fieldPath),
     textRangeBitset: (fieldPath, bounds) => textRangeBitsetOf(state, fieldPath, flat[fieldPath], bounds, capacity),
-    get allDocIds() {
-      if (!cachedAllDocIds) {
-        cachedAllDocIds = getAllInternalDocIds(state.docStore);
-      }
-      return cachedAllDocIds;
+    isPatternField: (fieldPath) => patternFields.has(fieldPath),
+    matchPattern: (fieldPath, operator, text, caseFold, into) => {
+      const index = state.patternIndexes.get(fieldPath);
+      if (index === void 0) return;
+      requirePatternSearch(fieldPath).matchInto({
+        operator,
+        text,
+        caseFold,
+        index,
+        matches: into,
+        meter,
+        host: PATTERN_HOST,
+        valueOf: (internalId) => getFieldValue(internalId, fieldPath)
+      });
+    },
+    presentBitset: (fieldPath) => {
+      const cached = cachedPresentBitsets.get(fieldPath);
+      if (cached !== void 0) return cached;
+      const present = presentBitsetOf(state, fieldPath, flat[fieldPath], capacity);
+      cachedPresentBitsets.set(fieldPath, present);
+      return present;
     },
     capacity,
     get allDocIdsBitset() {
-      if (!cachedAllDocIdsBitset) {
-        cachedAllDocIdsBitset = bitsetFromSet(this.allDocIds, capacity);
-      }
+      cachedAllDocIdsBitset ??= liveDocumentsBitset(state, capacity);
       return cachedAllDocIdsBitset;
     }
   };
 }
-function applyPartitionFilters(state, filters, schema) {
-  const context = buildFilterContext(state, schema);
+function applyPartitionFilters(state, filters, schema, meter) {
+  const context = buildFilterContext(state, schema, meter);
   const resultBitset = evaluateFilters(filters, context);
   const resolver = state.docStore.resolver();
   const externalResult = /* @__PURE__ */ new Set();
@@ -6749,12 +7360,12 @@ function applyPartitionFilters(state, filters, schema) {
   }
   return externalResult;
 }
-function applyPartitionFiltersBitset(state, filters, schema) {
-  const context = buildFilterContext(state, schema);
+function applyPartitionFiltersBitset(state, filters, schema, meter) {
+  const context = buildFilterContext(state, schema, meter);
   return evaluateFilters(filters, context);
 }
-function partitionFilterMatches(state, filters, schema) {
-  const accepted = applyPartitionFiltersBitset(state, filters, schema);
+function partitionFilterMatches(state, filters, schema, meter) {
+  const accepted = applyPartitionFiltersBitset(state, filters, schema, meter);
   const docStore = state.docStore;
   const resolver = docStore.resolver();
   let count = 0;
@@ -6911,6 +7522,8 @@ function estimatePartitionBytes(state) {
   bytes += docCount * state.booleanIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
   bytes += docCount * state.enumIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
   bytes += docCount * state.geoIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
+  bytes += docCount * state.sizeIndexes.size * FIELD_ENTRY_OVERHEAD_BYTES;
+  for (const index of state.patternIndexes.values()) bytes += index.bytes();
   return bytes + sortColumnBytes(state);
 }
 
@@ -6970,12 +7583,12 @@ function mergeSurfaceForms(target, source) {
     target.surfaceRegistry.add(surface, value[1], value[0]);
   }
 }
-function mergeFieldIndexes(target, source, idMapping) {
-  for (const [fieldPath, index] of source.numericIndexes) {
-    let targetIndex = target.numericIndexes.get(fieldPath);
+function mergeNumericIndexes(target, source, idMapping) {
+  for (const [fieldPath, index] of source) {
+    let targetIndex = target.get(fieldPath);
     if (targetIndex === void 0) {
       targetIndex = createNumericIndex();
-      target.numericIndexes.set(fieldPath, targetIndex);
+      target.set(fieldPath, targetIndex);
     }
     for (const entry of index.serialize()) {
       const targetInternalId = idMapping.get(entry.docId);
@@ -6983,6 +7596,10 @@ function mergeFieldIndexes(target, source, idMapping) {
       targetIndex.insert(targetInternalId, entry.value);
     }
   }
+}
+function mergeFieldIndexes(target, source, idMapping) {
+  mergeNumericIndexes(target.numericIndexes, source.numericIndexes, idMapping);
+  mergeNumericIndexes(target.sizeIndexes, source.sizeIndexes, idMapping);
   for (const [fieldPath, index] of source.booleanIndexes) {
     let targetIndex = target.booleanIndexes.get(fieldPath);
     if (targetIndex === void 0) {
@@ -7024,6 +7641,12 @@ function mergeFieldIndexes(target, source, idMapping) {
       targetIndex.insert(targetInternalId, entry.lat, entry.lon);
     }
   }
+  for (const [fieldPath, index] of source.patternIndexes) {
+    patternIndexOf(target.patternIndexes, fieldPath).addArrays(
+      index.toArrays(fieldPath, null),
+      (sourceInternalId) => idMapping.get(sourceInternalId) ?? -1
+    );
+  }
 }
 function mergeSegmentState(target, source) {
   if (source.stats.totalDocuments === 0 && source.docStore.count() === 0) return;
@@ -8044,19 +8667,23 @@ function searchFulltext(state, params) {
 }
 
 // src/core/partition/segment-field-indexes.ts
-function encodeFieldIndexes(state, remap) {
-  const survives = (internalId) => remap[internalId] >= 0;
-  const numeric = [];
-  for (const [fieldPath, index] of state.numericIndexes) {
-    const entries = index.serialize().filter((entry) => survives(entry.docId));
+function encodeNumericIndexes(indexes, remap) {
+  const encoded = [];
+  for (const [fieldPath, index] of indexes) {
+    const entries = index.serialize().filter((entry) => remap[entry.docId] >= 0);
     const docIds = new Uint32Array(entries.length);
     const values = new Float64Array(entries.length);
     for (let i = 0; i < entries.length; i++) {
       docIds[i] = remap[entries[i].docId];
       values[i] = entries[i].value;
     }
-    numeric.push({ fieldPath, docIds, values });
+    encoded.push({ fieldPath, docIds, values });
   }
+  return encoded;
+}
+function encodeFieldIndexes(state, remap) {
+  const survives = (internalId) => remap[internalId] >= 0;
+  const numeric = encodeNumericIndexes(state.numericIndexes, remap);
   const booleans = [];
   for (const [fieldPath, index] of state.booleanIndexes) {
     const { trueDocs, falseDocs } = index.serialize();
@@ -8097,7 +8724,9 @@ function encodeFieldIndexes(state, remap) {
     }
     geo.push({ fieldPath, docIds, latitudes, longitudes });
   }
-  return { numeric, boolean: booleans, enums, geo };
+  const pattern = [];
+  for (const [fieldPath, index] of state.patternIndexes) pattern.push(index.toArrays(fieldPath, remap));
+  return { numeric, boolean: booleans, enums, geo, pattern, sizes: encodeNumericIndexes(state.sizeIndexes, remap) };
 }
 
 // src/core/partition/segment-payload.ts
@@ -8254,15 +8883,19 @@ function mergePayloadPostings(target, payload, ordinalBase) {
     }
   }
 }
-function mergePayloadFieldIndexes(target, payload, ordinalBase) {
-  for (const entry of payload.numeric) {
-    let index = target.numericIndexes.get(entry.fieldPath);
+function mergePayloadNumericIndexes(target, entries, ordinalBase) {
+  for (const entry of entries) {
+    let index = target.get(entry.fieldPath);
     if (index === void 0) {
       index = createNumericIndex();
-      target.numericIndexes.set(entry.fieldPath, index);
+      target.set(entry.fieldPath, index);
     }
     for (let i = 0; i < entry.docIds.length; i++) index.insert(ordinalBase + entry.docIds[i], entry.values[i]);
   }
+}
+function mergePayloadFieldIndexes(target, payload, ordinalBase) {
+  mergePayloadNumericIndexes(target.numericIndexes, payload.numeric, ordinalBase);
+  mergePayloadNumericIndexes(target.sizeIndexes, payload.sizes, ordinalBase);
   for (const entry of payload.boolean) {
     let index = target.booleanIndexes.get(entry.fieldPath);
     if (index === void 0) {
@@ -8293,6 +8926,9 @@ function mergePayloadFieldIndexes(target, payload, ordinalBase) {
       index.insert(ordinalBase + entry.docIds[i], entry.latitudes[i], entry.longitudes[i]);
     }
   }
+  for (const entry of payload.pattern) {
+    patternIndexOf(target.patternIndexes, entry.fieldPath).addArrays(entry, (ordinal) => ordinalBase + ordinal);
+  }
 }
 function mergeSegmentPayload(target, payload, documents) {
   if (payload.documentCount === 0) return;
@@ -8337,6 +8973,123 @@ function mergeSegmentPayload(target, payload, documents) {
   target.scoreBuffer = null;
 }
 
+// src/core/partition/pattern-snapshot.ts
+function loadFailed(fieldPath, problem) {
+  return new NarsilError(
+    ErrorCodes.PERSISTENCE_LOAD_FAILED,
+    `The pattern index of field "${fieldPath}" in this partition is corrupt: ${problem}`,
+    { field: fieldPath }
+  );
+}
+function serializePatternIndex(state, fieldPath, index) {
+  const resolver = state.docStore.resolver();
+  const arrays = index.toArrays(fieldPath, null);
+  const positionOf = /* @__PURE__ */ new Map();
+  const docIds = [];
+  for (const ordinal of arrays.docIds) {
+    const externalId = resolver.toExternal(ordinal);
+    if (externalId === void 0) continue;
+    positionOf.set(ordinal, docIds.length);
+    docIds.push(externalId);
+  }
+  const runs = /* @__PURE__ */ Object.create(null);
+  for (let run = 0; run + 1 < arrays.offsets.length; run++) {
+    const positions = [];
+    for (let at = arrays.offsets[run]; at < arrays.offsets[run + 1]; at++) {
+      const position = positionOf.get(arrays.postings[at]);
+      if (position !== void 0) positions.push(position);
+    }
+    if (positions.length === 0) continue;
+    const base = run * PATTERN_RUN_CODE_POINTS;
+    runs[String.fromCodePoint(arrays.runs[base], arrays.runs[base + 1], arrays.runs[base + 2])] = positions;
+  }
+  return { docIds, runs };
+}
+function serializePatternIndexes(state, schema) {
+  const patternFields = schemaFieldsOf(schema).filter((field) => field.pattern);
+  if (patternFields.length === 0) return void 0;
+  const serialized = /* @__PURE__ */ Object.create(null);
+  for (const { path: fieldPath } of patternFields) {
+    const index = state.patternIndexes.get(fieldPath);
+    serialized[fieldPath] = index === void 0 ? { docIds: [], runs: {} } : serializePatternIndex(state, fieldPath, index);
+  }
+  return serialized;
+}
+function appendRunCodePoints(fieldPath, key, out) {
+  const start = out.length;
+  for (const character of key) out.push(character.codePointAt(0) ?? 0);
+  const count = out.length - start;
+  if (count !== PATTERN_RUN_CODE_POINTS) {
+    throw loadFailed(
+      fieldPath,
+      `the key "${key}" holds ${count} code points, while each key must hold ${PATTERN_RUN_CODE_POINTS}`
+    );
+  }
+}
+function requirePositions(fieldPath, key, list, documentCount) {
+  if (!Array.isArray(list)) throw loadFailed(fieldPath, `the run "${key}" must map to a list of positions`);
+  let previous = -1;
+  for (const position of list) {
+    if (!Number.isInteger(position) || position < 0 || position >= documentCount) {
+      throw loadFailed(fieldPath, `the run "${key}" names position ${String(position)} outside its document list`);
+    }
+    if (position <= previous) {
+      throw loadFailed(fieldPath, `the positions of the run "${key}" are out of ascending order`);
+    }
+    previous = position;
+  }
+  return list;
+}
+function requireDistinctDocuments(fieldPath, docIds) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const docId of docIds) {
+    if (seen.has(docId)) throw loadFailed(fieldPath, `the document list names "${docId}" twice`);
+    seen.add(docId);
+  }
+}
+function decodePatternEntry(fieldPath, entry) {
+  requireDistinctDocuments(fieldPath, entry.docIds);
+  const runs = [];
+  const offsets = [0];
+  const postings = [];
+  for (const [key, list] of Object.entries(entry.runs)) {
+    appendRunCodePoints(fieldPath, key, runs);
+    for (const position of requirePositions(fieldPath, key, list, entry.docIds.length)) postings.push(position);
+    offsets.push(postings.length);
+  }
+  const positions = new Uint32Array(entry.docIds.length);
+  for (let position = 0; position < positions.length; position++) positions[position] = position;
+  return {
+    fieldPath,
+    docIds: positions,
+    runs: Uint32Array.from(runs),
+    offsets: Uint32Array.from(offsets),
+    postings: Uint32Array.from(postings)
+  };
+}
+function rebuildPatternIndex(state, fieldPath) {
+  for (const [docId, stored] of state.docStore.all()) {
+    const value = getNestedValue(stored.fields, fieldPath);
+    if (value === void 0 || value === null) continue;
+    const internalId = state.docStore.getInternalId(docId);
+    if (internalId !== void 0) patternIndexOf(state.patternIndexes, fieldPath).add(internalId, value);
+  }
+}
+function loadPatternIndexes(state, serialized, schema) {
+  const resolver = state.docStore.resolver();
+  for (const { path: fieldPath, pattern } of schemaFieldsOf(schema)) {
+    if (!pattern) continue;
+    const entry = serialized !== void 0 && Object.hasOwn(serialized, fieldPath) ? serialized[fieldPath] : void 0;
+    if (entry === void 0) {
+      rebuildPatternIndex(state, fieldPath);
+      continue;
+    }
+    const decoded = decodePatternEntry(fieldPath, entry);
+    const ordinals = entry.docIds.map((docId) => resolver.toInternal(docId) ?? -1);
+    patternIndexOf(state.patternIndexes, fieldPath).addArrays(decoded, (position) => ordinals[position]);
+  }
+}
+
 // src/core/partition/serialization.ts
 function serializePartition(state, partitionId, indexName, totalPartitions, language, schema) {
   const flatSchema = getFlatSchema(state, schema);
@@ -8409,6 +9162,7 @@ function serializePartition(state, partitionId, indexName, totalPartitions, lang
     }));
   }
   const serializedStats = state.stats.serialize();
+  const serializedPattern = serializePatternIndexes(state, schema);
   return {
     indexName,
     partitionId,
@@ -8423,7 +9177,8 @@ function serializePartition(state, partitionId, indexName, totalPartitions, lang
       numeric: serializedNumeric,
       boolean: serializedBoolean,
       enum: serializedEnum,
-      geopoint: serializedGeo
+      geopoint: serializedGeo,
+      ...serializedPattern === void 0 ? {} : { pattern: serializedPattern }
     },
     surfaceForms: state.surfaceRegistry.serialize(),
     statistics: serializedStats
@@ -8501,6 +9256,8 @@ function deserializePartition(state, data, clearFn, schema) {
       throw new Error(`Schema mismatch: serialized data contains unknown field "${field}" not present in schema`);
     }
   }
+  loadPatternIndexes(state, data.fieldIndexes.pattern, schema);
+  rebuildSizeIndexes(state, schema);
 }
 
 // src/core/partition/suggestions.ts
@@ -8663,7 +9420,8 @@ function serializePartitionToWirePayloadV2(state, partitionId, indexName, totalP
       numeric: wireNumeric,
       boolean: wireBoolean,
       enum: wireEnum,
-      geopoint: wireGeo
+      geopoint: wireGeo,
+      ...patternIndexesToWire(serializePatternIndexes(state, schema))
     },
     surface_forms: state.surfaceRegistry.serialize(),
     statistics: {
@@ -8698,6 +9456,8 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     booleanIndexes: /* @__PURE__ */ new Map(),
     enumIndexes: /* @__PURE__ */ new Map(),
     geoIndexes: /* @__PURE__ */ new Map(),
+    patternIndexes: /* @__PURE__ */ new Map(),
+    sizeIndexes: /* @__PURE__ */ new Map(),
     fieldNameTable,
     flatSchemaCache: null,
     lastSchemaRef: null,
@@ -8717,6 +9477,8 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     state.booleanIndexes.clear();
     state.enumIndexes.clear();
     state.geoIndexes.clear();
+    state.patternIndexes.clear();
+    state.sizeIndexes.clear();
     state.stats.deserialize({ totalDocuments: 0, totalFieldLengths: {}, averageFieldLengths: {}, docFrequencies: {} });
     state.flatSchemaCache = null;
     state.lastSchemaRef = null;
@@ -8892,14 +9654,14 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     sortValues(docId, fields, fieldTypes, modes) {
       return sortValuesOf(state, docId, fields, fieldTypes, modes);
     },
-    applyFilters(filters, schema) {
-      return applyPartitionFilters(state, filters, schema);
+    applyFilters(filters, schema, meter) {
+      return applyPartitionFilters(state, filters, schema, meter);
     },
-    applyFiltersBitset(filters, schema) {
-      return applyPartitionFiltersBitset(state, filters, schema);
+    applyFiltersBitset(filters, schema, meter) {
+      return applyPartitionFiltersBitset(state, filters, schema, meter);
     },
-    filterMatches(filters, schema) {
-      return partitionFilterMatches(state, filters, schema);
+    filterMatches(filters, schema, meter) {
+      return partitionFilterMatches(state, filters, schema, meter);
     },
     computeFacets(matched, config, schema) {
       return computeFacets(state, matched, config, schema);
@@ -9281,6 +10043,100 @@ function readHeapStatistics() {
   return null;
 }
 
+// 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 shared2 = {
+        cap,
+        spent: seed,
+        counter,
+        matcherStateBytes: Math.floor(matcherStateBytes / copies),
+        flushUnits: Math.max(1, Math.floor(flushUnits / copies))
+      };
+      return {
+        shared: shared2,
+        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, {
@@ -9938,7 +10794,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 };
@@ -10181,7 +11041,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) {
@@ -10216,12 +11077,13 @@ function frozenSegmentBytes(segment) {
     bytes += arrays.documentTable.blob.byteLength + arrays.documentTable.offsets.byteLength;
   }
   for (const column of arrays.fieldLengthColumns) bytes += column.byteLength;
-  for (const entry of arrays.numeric) bytes += entry.docIds.byteLength + entry.values.byteLength;
+  for (const entry of [...arrays.numeric, ...arrays.sizes]) bytes += entry.docIds.byteLength + entry.values.byteLength;
   for (const entry of arrays.boolean) bytes += entry.trueDocs.byteLength + entry.falseDocs.byteLength;
   for (const entry of arrays.enums) bytes += entry.offsets.byteLength + entry.docIds.byteLength;
   for (const entry of arrays.geo) {
     bytes += entry.docIds.byteLength + entry.latitudes.byteLength + entry.longitudes.byteLength;
   }
+  for (const reader of segment.patternIndexes.values()) bytes += reader.bytes();
   return bytes;
 }
 
@@ -10299,24 +11161,24 @@ function placeSubBitset(composite, layout, subIndex, subBits) {
   if (words === 0) return;
   composite.set(subBits.length > words ? subBits.subarray(0, words) : subBits, layout.bases[subIndex] >> 5);
 }
-function compositeFiltersBitset(subs, layout, filters, schema) {
+function compositeFiltersBitset(subs, layout, filters, schema, meter) {
   const composite = new Uint32Array(Math.ceil(layout.totalCapacity / WORD_BITS));
   for (let i = 0; i < subs.length; i++) {
-    placeSubBitset(composite, layout, i, applyPartitionFiltersBitset(subs[i], filters, schema));
+    placeSubBitset(composite, layout, i, applyPartitionFiltersBitset(subs[i], filters, schema, meter));
   }
   return composite;
 }
-function compositeFilters(subs, filters, schema) {
+function compositeFilters(subs, filters, schema, meter) {
   const combined = /* @__PURE__ */ new Set();
   for (const sub of subs) {
-    for (const docId of applyPartitionFilters(sub, filters, schema)) {
+    for (const docId of applyPartitionFilters(sub, filters, schema, meter)) {
       combined.add(docId);
     }
   }
   return combined;
 }
-function compositeFilterMatches(subs, layout, filters, schema) {
-  const bits = compositeFiltersBitset(subs, layout, filters, schema);
+function compositeFilterMatches(subs, layout, filters, schema, meter) {
+  const bits = compositeFiltersBitset(subs, layout, filters, schema, meter);
   let count = 0;
   for (let i = 0; i < subs.length; i++) {
     const resolver = subs[i].docStore.resolver();
@@ -10777,14 +11639,14 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
     searchFulltextMatches(params) {
       return compositeSearchMatches(subs(), layout(), params);
     },
-    applyFilters(filters, schema) {
-      return compositeFilters(subs(), filters, schema);
+    applyFilters(filters, schema, meter) {
+      return compositeFilters(subs(), filters, schema, meter);
     },
-    applyFiltersBitset(filters, schema) {
-      return compositeFiltersBitset(subs(), layout(), filters, schema);
+    applyFiltersBitset(filters, schema, meter) {
+      return compositeFiltersBitset(subs(), layout(), filters, schema, meter);
     },
-    filterMatches(filters, schema) {
-      return compositeFilterMatches(subs(), layout(), filters, schema);
+    filterMatches(filters, schema, meter) {
+      return compositeFilterMatches(subs(), layout(), filters, schema, meter);
     },
     computeFacets(matched, config, schema) {
       const everyValue = everyValueFacetConfig(config);
@@ -10954,6 +11816,7 @@ function setNestedValue(obj, path, value) {
 
 // src/partitioning/manager/index.ts
 function createPartitionManager(indexName, config, language, router, initialPartitionCount, vectorIndexes) {
+  requirePatternSearchFor(config.schema);
   const count = initialPartitionCount ?? 1;
   const analysis = resolveIndexAnalysis(config);
   const trackPositions = config.trackPositions ?? true;
@@ -11265,8 +12128,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;
@@ -17951,7 +18818,22 @@ function createFrozenEnumReader(entry) {
   function rangeOf(value) {
     return rangeByValue.get(value) ?? { from: 0, to: 0 };
   }
+  let affixes = null;
+  function affixesOf() {
+    affixes ??= new ValueAffixes(() => true, values);
+    return affixes;
+  }
+  function bitsetOfValues(matching, capacity) {
+    const bits = createBitSet(capacity);
+    for (const value of matching) {
+      const { from, to } = rangeOf(value);
+      for (let i = from; i < to; i++) bitsetSet(bits, docIds[i]);
+    }
+    return bits;
+  }
   return {
+    queryPrefixBitset: (prefix, capacity) => bitsetOfValues(affixesOf().withPrefix(prefix), capacity),
+    querySuffixBitset: (suffix, capacity) => bitsetOfValues(affixesOf().withSuffix(suffix), capacity),
     serialize: () => {
       const byValue = /* @__PURE__ */ Object.create(null);
       for (let i = 0; i < values.length; i++) {
@@ -18396,6 +19278,11 @@ function freezeEncodedSegmentShared(payload, documentData, segmentId) {
       docIds: sharedUint32(entry.docIds),
       values: sharedFloat64(entry.values)
     })),
+    sizes: payload.sizes.map((entry) => ({
+      fieldPath: entry.fieldPath,
+      docIds: sharedUint32(entry.docIds),
+      values: sharedFloat64(entry.values)
+    })),
     boolean: payload.boolean.map((entry) => ({
       fieldPath: entry.fieldPath,
       trueDocs: sharedUint32(entry.trueDocs),
@@ -18413,6 +19300,13 @@ function freezeEncodedSegmentShared(payload, documentData, segmentId) {
       latitudes: sharedFloat64(entry.latitudes),
       longitudes: sharedFloat64(entry.longitudes)
     })),
+    pattern: payload.pattern.map((entry) => ({
+      fieldPath: entry.fieldPath,
+      docIds: sharedUint32(entry.docIds),
+      runs: sharedUint32(entry.runs),
+      offsets: sharedUint32(entry.offsets),
+      postings: sharedUint32(entry.postings)
+    })),
     surfaceTable: sharedSurfaceTable(payload)
   };
 }
@@ -18459,10 +19353,16 @@ function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot
   const docStore = createFrozenDocTable(source.idTable, lengthColumns, documentSource, tombstones);
   const numericIndexes = /* @__PURE__ */ new Map();
   for (const entry of source.numeric) numericIndexes.set(entry.fieldPath, createFrozenNumericReader(entry));
+  const sizeIndexes = /* @__PURE__ */ new Map();
+  for (const entry of source.sizes) sizeIndexes.set(entry.fieldPath, createFrozenNumericReader(entry));
   const booleanIndexes = /* @__PURE__ */ new Map();
   for (const entry of source.boolean) booleanIndexes.set(entry.fieldPath, createFrozenBooleanReader(entry));
   const enumIndexes = /* @__PURE__ */ new Map();
   for (const entry of source.enums) enumIndexes.set(entry.fieldPath, createFrozenEnumReader(entry));
+  const patternIndexes = /* @__PURE__ */ new Map();
+  for (const entry of source.pattern) {
+    patternIndexes.set(entry.fieldPath, requirePatternSearch(entry.fieldPath).readArrays(entry));
+  }
   const fieldNameTable = {
     names: [...source.fieldNames],
     indexMap: new Map(source.fieldNames.map((name, index) => [name, index]))
@@ -18480,6 +19380,8 @@ function assembleFrozenSegment(segmentId, source, documentSource, sharedSnapshot
     booleanIndexes,
     enumIndexes,
     geoIndexes: buildGeoReaders(source.geo),
+    patternIndexes,
+    sizeIndexes,
     fieldNameTable,
     trackPositions: source.positionOffsets !== null,
     flatSchemaCache: null,
@@ -18607,12 +19509,8 @@ function remapDocIds(inputs, pick) {
   }
   return out;
 }
-function mergeNumeric(inputs) {
-  const byFieldPath = rowsByFieldPath(
-    inputs,
-    (input) => input.segment.arrays.numeric,
-    (entry, at) => [entry.values[at]]
-  );
+function mergeNumeric(inputs, pick) {
+  const byFieldPath = rowsByFieldPath(inputs, pick, (entry, at) => [entry.values[at]]);
   const merged = [];
   for (const [fieldPath, rows] of byFieldPath) {
     rows.sort((a, b) => a.values[0] - b.values[0] || a.docId - b.docId);
@@ -18685,12 +19583,32 @@ function mergeEnums(inputs) {
   }
   return merged;
 }
+function mergePattern(inputs) {
+  const byFieldPath = /* @__PURE__ */ new Map();
+  for (const input of inputs) {
+    for (const arrays of input.segment.arrays.pattern) {
+      let entries = byFieldPath.get(arrays.fieldPath);
+      if (entries === void 0) {
+        entries = [];
+        byFieldPath.set(arrays.fieldPath, entries);
+      }
+      entries.push({ arrays, remap: input.remap });
+    }
+  }
+  const merged = [];
+  for (const [fieldPath, entries] of byFieldPath) {
+    merged.push(requirePatternSearch(fieldPath).mergeArrays(fieldPath, entries));
+  }
+  return merged;
+}
 function mergeFieldIndexes2(inputs) {
   return {
-    numeric: mergeNumeric(inputs),
+    numeric: mergeNumeric(inputs, (input) => input.segment.arrays.numeric),
     boolean: mergeBoolean(inputs),
     enums: mergeEnums(inputs),
-    geo: mergeGeo(inputs)
+    geo: mergeGeo(inputs),
+    pattern: mergePattern(inputs),
+    sizes: mergeNumeric(inputs, (input) => input.segment.arrays.sizes)
   };
 }
 
@@ -19032,54 +19950,7 @@ var GrowableUint32 = class {
   }
 };
 
-// src/core/partition/segment-builder.ts
-var TOKEN_TABLE_START = 1 << 12;
-var POSTING_LOG_START = 1 << 14;
-var POSITION_POOL_START = 1 << 16;
-var FIELD_SCRATCH_START = 1 << 10;
-function indexOf(indexes, fieldPath, create) {
-  let index = indexes.get(fieldPath);
-  if (index === void 0) {
-    index = create();
-    indexes.set(fieldPath, index);
-  }
-  return index;
-}
-function indexFilterValue(indexes, ordinal, fieldPath, fieldType, value) {
-  if (fieldType === "number" || fieldType === "number[]") {
-    const index = indexOf(indexes.numericIndexes, fieldPath, createNumericIndex);
-    for (const entry of fieldType === "number" ? [value] : value) index.insert(ordinal, entry);
-  } else if (fieldType === "boolean" || fieldType === "boolean[]") {
-    const index = indexOf(indexes.booleanIndexes, fieldPath, createBooleanIndex);
-    for (const entry of fieldType === "boolean" ? [value] : value)
-      index.insert(ordinal, entry);
-  } else if (fieldType === "enum" || fieldType === "enum[]") {
-    const index = indexOf(indexes.enumIndexes, fieldPath, createEnumIndex);
-    for (const entry of fieldType === "enum" ? [value] : value) index.insert(ordinal, entry);
-  } else if (fieldType === "geopoint") {
-    const point = value;
-    indexOf(indexes.geoIndexes, fieldPath, createGeoIndex).insert(ordinal, point.lat, point.lon);
-  }
-}
-function refuseRepeatedDocIds(documents) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const { docId } of documents) {
-    if (seen.has(docId)) {
-      throw new NarsilError(ErrorCodes.DOC_ALREADY_EXISTS, `Document "${docId}" already exists in partition 0`, {
-        docId,
-        partitionId: 0
-      });
-    }
-    seen.add(docId);
-  }
-}
-function validateAsAnInsertDoes(documents, schema, options) {
-  if (options?.validate === false) return;
-  for (const { document: document2 } of documents) {
-    validateDocument(document2, schema, options?.patternValueLimit);
-    if (options?.strict) validateDocumentStrict(document2, schema);
-  }
-}
+// src/core/partition/segment-postings.ts
 var TextPostings = class {
   constructor(trackPositions) {
     this.trackPositions = trackPositions;
@@ -19088,22 +19959,22 @@ var TextPostings = class {
   fieldNames = [];
   tokenIds = /* @__PURE__ */ new Map();
   fieldNameIndexes = /* @__PURE__ */ new Map();
-  postingsPerToken = new GrowableUint32(TOKEN_TABLE_START);
-  docFrequencyPerToken = new GrowableUint32(TOKEN_TABLE_START);
-  lastDocPerToken = new GrowableUint32(TOKEN_TABLE_START);
-  fieldStampPerToken = new GrowableUint32(TOKEN_TABLE_START);
-  fieldSlotPerToken = new GrowableUint32(TOKEN_TABLE_START);
-  logToken = new GrowableUint32(POSTING_LOG_START);
-  logDoc = new GrowableUint32(POSTING_LOG_START);
-  logFrequency = new GrowableUint32(POSTING_LOG_START);
-  logField = new GrowableUint32(POSTING_LOG_START);
-  logPositionStart = new GrowableUint32(POSTING_LOG_START);
-  positionPool = new GrowableUint32(POSITION_POOL_START);
-  slotToken = new GrowableUint32(FIELD_SCRATCH_START);
-  slotCount = new GrowableUint32(FIELD_SCRATCH_START);
-  slotCursor = new GrowableUint32(FIELD_SCRATCH_START);
-  eventSlot = new GrowableUint32(FIELD_SCRATCH_START);
-  eventPosition = new GrowableUint32(FIELD_SCRATCH_START);
+  postingsPerToken = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
+  docFrequencyPerToken = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
+  lastDocPerToken = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
+  fieldStampPerToken = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
+  fieldSlotPerToken = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
+  logToken = new GrowableUint32(SEGMENT_POSTING_LOG_START);
+  logDoc = new GrowableUint32(SEGMENT_POSTING_LOG_START);
+  logFrequency = new GrowableUint32(SEGMENT_POSTING_LOG_START);
+  logField = new GrowableUint32(SEGMENT_POSTING_LOG_START);
+  logPositionStart = new GrowableUint32(SEGMENT_POSTING_LOG_START);
+  positionPool = new GrowableUint32(SEGMENT_POSITION_POOL_START);
+  slotToken = new GrowableUint32(SEGMENT_FIELD_SCRATCH_START);
+  slotCount = new GrowableUint32(SEGMENT_FIELD_SCRATCH_START);
+  slotCursor = new GrowableUint32(SEGMENT_FIELD_SCRATCH_START);
+  eventSlot = new GrowableUint32(SEGMENT_FIELD_SCRATCH_START);
+  eventPosition = new GrowableUint32(SEGMENT_FIELD_SCRATCH_START);
   fieldStamp = 0;
   beginField() {
     this.fieldStamp++;
@@ -19231,11 +20102,56 @@ var TextPostings = class {
     };
   }
 };
+
+// src/core/partition/segment-builder.ts
+function indexOf(indexes, fieldPath, create) {
+  let index = indexes.get(fieldPath);
+  if (index === void 0) {
+    index = create();
+    indexes.set(fieldPath, index);
+  }
+  return index;
+}
+function indexFilterValue(indexes, ordinal, fieldPath, fieldType, value) {
+  if (fieldType === "number" || fieldType === "number[]") {
+    const index = indexOf(indexes.numericIndexes, fieldPath, createNumericIndex);
+    for (const entry of fieldType === "number" ? [value] : value) index.insert(ordinal, entry);
+  } else if (fieldType === "boolean" || fieldType === "boolean[]") {
+    const index = indexOf(indexes.booleanIndexes, fieldPath, createBooleanIndex);
+    for (const entry of fieldType === "boolean" ? [value] : value)
+      index.insert(ordinal, entry);
+  } else if (fieldType === "enum" || fieldType === "enum[]") {
+    const index = indexOf(indexes.enumIndexes, fieldPath, createEnumIndex);
+    for (const entry of fieldType === "enum" ? [value] : value) index.insert(ordinal, entry);
+  } else if (fieldType === "geopoint") {
+    const point = value;
+    indexOf(indexes.geoIndexes, fieldPath, createGeoIndex).insert(ordinal, point.lat, point.lon);
+  }
+}
+function refuseRepeatedDocIds(documents) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const { docId } of documents) {
+    if (seen.has(docId)) {
+      throw new NarsilError(ErrorCodes.DOC_ALREADY_EXISTS, `Document "${docId}" already exists in partition 0`, {
+        docId,
+        partitionId: 0
+      });
+    }
+    seen.add(docId);
+  }
+}
+function validateAsAnInsertDoes(documents, schema, options) {
+  if (options?.validate === false) return;
+  for (const { document: document2 } of documents) {
+    validateDocument(document2, schema, options?.patternValueLimit);
+    if (options?.strict) validateDocumentStrict(document2, schema);
+  }
+}
 var SurfaceCounts = class {
   ids = /* @__PURE__ */ new Map();
   surfaces = [];
   tokens = [];
-  counts = new GrowableUint32(TOKEN_TABLE_START);
+  counts = new GrowableUint32(SEGMENT_TOKEN_TABLE_START);
   count(surface, token) {
     if (surface === void 0 || surface.length === 0) return;
     const known = this.ids.get(surface);
@@ -19295,7 +20211,9 @@ function buildSegmentPayload(documents, schema, language, options, trackPosition
     numericIndexes: /* @__PURE__ */ new Map(),
     booleanIndexes: /* @__PURE__ */ new Map(),
     enumIndexes: /* @__PURE__ */ new Map(),
-    geoIndexes: /* @__PURE__ */ new Map()
+    geoIndexes: /* @__PURE__ */ new Map(),
+    patternIndexes: /* @__PURE__ */ new Map(),
+    sizeIndexes: /* @__PURE__ */ new Map()
   };
   let positionOffset = 0;
   const addToken = (token, position, surface) => {
@@ -19304,9 +20222,11 @@ function buildSegmentPayload(documents, schema, language, options, trackPosition
   };
   for (let ordinal = 0; ordinal < documents.length; ordinal++) {
     const document2 = documents[ordinal].document;
-    for (const { path: fieldPath, base: fieldType } of fields) {
+    for (const { path: fieldPath, base: fieldType, pattern } of fields) {
       const value = getNestedValue(document2, fieldPath);
       if (value === void 0 || value === null) continue;
+      recordValueSize(filters.sizeIndexes, ordinal, fieldPath, fieldType, value);
+      if (pattern) patternIndexOf(filters.patternIndexes, fieldPath).add(ordinal, value);
       if (!isWordIndexedBase(fieldType)) {
         indexFilterValue(filters, ordinal, fieldPath, fieldType, value);
         continue;
@@ -19831,6 +20751,7 @@ function createDirectExecutor(options) {
       }
       case "query": {
         const entry = requireIndex(action.indexName);
+        const patternWork = joinPatternWorkMeter(action.patternWork);
         const result = await fanOutQuery(
           entry.manager,
           action.params,
@@ -19841,15 +20762,17 @@ function createDirectExecutor(options) {
             partitionIds: action.partitionIds,
             ...action.globalStats !== void 0 ? { globalStats: sanitizeGlobalStats(action.globalStats) } : {}
           },
-          entry.searchOptions
+          { ...entry.searchOptions, patternWork }
         );
+        result.patternWorkSpent = patternWork.spent();
         return result;
       }
       case "preflight": {
         const entry = requireIndex(action.indexName);
+        const searchOptions = { ...entry.searchOptions, patternWork: joinPatternWorkMeter(action.patternWork) };
         if (countsWithoutScores(action.params)) {
           const count = fanOutMatchCount(entry.manager, action.params, entry.language, entry.config.schema, {
-            searchOptions: entry.searchOptions
+            searchOptions
           });
           return { count };
         }
@@ -19859,7 +20782,7 @@ function createDirectExecutor(options) {
           entry.language,
           entry.config.schema,
           { scoringMode: entry.config.defaultScoring ?? "local" },
-          entry.searchOptions
+          searchOptions
         );
         return { count: result.totalMatched };
       }
@@ -25245,6 +26168,13 @@ function validateDocId(docId) {
   if (docId.includes("\0")) {
     throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Document ID must not contain null bytes", { docId });
   }
+  if (holdsUnpairedSurrogate(docId)) {
+    throw new NarsilError(
+      ErrorCodes.DOC_VALIDATION_FAILED,
+      "Document ID 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",
+      { docId }
+    );
+  }
 }
 function validatePartitionConfig(partitions) {
   const { maxDocsPerPartition, maxPartitions, watermark } = partitions;
@@ -27707,6 +28637,64 @@ function stopIdleSweep(state) {
   state.idleSweep = null;
 }
 
+// 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/core/pattern-index/query-positions.ts
+function isRecord5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function textPositions(text, caseFold) {
+  if (typeof text !== "string") return 0;
+  return caseFold ? foldedCodePointCount(text) : codePointCount(text);
+}
+function larger(left, right) {
+  if (left === null) return right;
+  if (right === null) return left;
+  return Math.max(left, right);
+}
+function largestTestOf(filter) {
+  const caseFold = filter.caseFold === true;
+  let largest = null;
+  for (const operator of PATTERN_TEST_OPERATORS) {
+    const operand = filter[operator];
+    if (operand === void 0) continue;
+    const texts = Array.isArray(operand) ? operand : [operand];
+    for (const text of texts) largest = larger(largest, textPositions(text, caseFold));
+  }
+  return largest;
+}
+function largestIn(expression, patternFields) {
+  let largest = null;
+  if (isRecord5(expression.fields)) {
+    for (const [fieldPath, filter] of Object.entries(expression.fields)) {
+      if (patternFields.has(fieldPath) && isRecord5(filter)) largest = larger(largest, largestTestOf(filter));
+    }
+  }
+  const nested = [...expression.and ?? [], ...expression.or ?? []];
+  if (expression.not !== void 0) nested.push(expression.not);
+  for (const child of nested) largest = larger(largest, largestIn(child, patternFields));
+  return largest;
+}
+function largestPatternTest(expression, schema) {
+  if (expression === void 0) return null;
+  const patternFields = /* @__PURE__ */ new Set();
+  for (const { path, pattern } of schemaFieldsOf(schema)) if (pattern) patternFields.add(path);
+  return patternFields.size === 0 ? null : largestIn(expression, patternFields);
+}
+
 // src/engine/orchestration/search.ts
 function partitionsPerLease(scope, leaseCount) {
   const assignments = Array.from({ length: leaseCount }, () => []);
@@ -27718,15 +28706,18 @@ function partitionsPerLease(scope, leaseCount) {
 function mergeWorkerResults(results, facetConfig) {
   const merged = kWayMerge(results.map((result) => result.scored));
   let totalMatched = 0;
+  let patternWorkSpent = 0;
   const workerFacets = [];
   for (const result of results) {
     totalMatched += result.totalMatched;
+    patternWorkSpent += result.patternWorkSpent ?? 0;
     if (result.facets !== void 0) workerFacets.push(result.facets);
   }
   return {
     scored: merged,
     totalMatched,
-    facets: facetConfig !== void 0 && workerFacets.length > 0 ? mergeFacets(workerFacets, facetConfig) : void 0
+    facets: facetConfig !== void 0 && workerFacets.length > 0 ? mergeFacets(workerFacets, facetConfig) : void 0,
+    patternWorkSpent
   };
 }
 function scoresPerPartition(state, indexName, params, globalStats) {
@@ -27734,26 +28725,45 @@ function scoresPerPartition(state, indexName, params, globalStats) {
   if (mode === "local") return true;
   return mode === "broadcast" && globalStats !== void 0;
 }
-function queryAction(indexName, params, globalStats, partitionIds) {
+function queryAction(indexName, params, globalStats, partitionIds, patternWork) {
   return {
     type: "query",
     indexName,
     params,
     requestId: createRequestId(),
+    patternWork,
     ...partitionIds !== void 0 ? { partitionIds } : {},
     ...globalStats !== void 0 ? { globalStats } : {}
   };
 }
-async function runSplit(leases, scope, indexName, params, globalStats) {
+async function runSplit(leases, scope, indexName, params, globalStats, patternWork) {
   const assignments = partitionsPerLease(scope, leases.length);
   const workerParams = params.facets !== void 0 ? { ...params, facets: oversampledFacetConfig(params.facets) } : params;
-  const results = await Promise.all(
+  const outcomes = await Promise.allSettled(
     assignments.map(
-      (partitionIds, at) => leases[at].executor.execute(queryAction(indexName, workerParams, globalStats, partitionIds)).finally(() => leases[at].release())
+      (partitionIds, at) => leases[at].executor.execute(queryAction(indexName, workerParams, globalStats, partitionIds, patternWork)).finally(() => leases[at].release())
     )
   );
+  const results = [];
+  const failures = [];
+  for (const outcome of outcomes) {
+    if (outcome.status === "fulfilled") results.push(outcome.value);
+    else failures.push(outcome.reason);
+  }
+  if (failures.length > 0) throw failures.find(isWorkCapError) ?? failures[0];
   return mergeWorkerResults(results, params.facets);
 }
+function isWorkCapError(err) {
+  return err instanceof NarsilError && err.code === ErrorCodes.SEARCH_WORK_CAP_EXCEEDED;
+}
+function patternSplitWidth(state, indexName, params) {
+  const schema = state.indexRegistry.get(indexName)?.config.schema;
+  if (schema === void 0) return Number.POSITIVE_INFINITY;
+  const largest = largestPatternTest(params.filters, schema);
+  if (largest === null) return Number.POSITIVE_INFINITY;
+  if (typeof SharedArrayBuffer !== "function") return 1;
+  return widestPatternSplit(largest);
+}
 function takeMainCopyTurn(state) {
   if (state.mainCopyQueries === "none" || state.mainCopyTurnTaken) return false;
   state.mainCopyTurnTaken = true;
@@ -27767,7 +28777,7 @@ function answersFasterOnMainCopy(state, pool, manager) {
   if (manager.countDocuments() > MAIN_COPY_LONE_QUERY_DOCUMENTS) return false;
   return takeMainCopyTurn(state);
 }
-async function searchViaWorker(state, indexName, params, globalStats, partitionIds) {
+async function searchViaWorker(state, indexName, params, globalStats, partitionIds, patternWork) {
   const pool = state.workerPool;
   if (!pool) return null;
   if (!state.scaledOutIndexes.has(indexName) || state.copyLoadBuffers.has(indexName)) return null;
@@ -27775,19 +28785,30 @@ async function searchViaWorker(state, indexName, params, globalStats, partitionI
   if (!manager) return null;
   if (answersFasterOnMainCopy(state, pool, manager)) return null;
   const scope = partitionIds ?? Array.from({ length: manager.partitionCount }, (_, partitionId) => partitionId);
-  const idle = pool.leaseIdle(scope.length);
+  const idle = pool.leaseIdle(Math.min(scope.length, patternSplitWidth(state, indexName, params)));
   const leases = [];
+  let fork = null;
   try {
     if (idle.length >= 2 && scoresPerPartition(state, indexName, params, globalStats)) {
       leases.push(...idle);
-      return await runSplit(leases, scope, indexName, params, globalStats);
+      fork = patternWork.fork(leases.length);
+      const merged = await runSplit(leases, scope, indexName, params, globalStats, fork.shared);
+      fork.settle(merged.patternWorkSpent ?? 0);
+      return merged;
     }
     for (const lease2 of idle.slice(1)) lease2.release();
     const lease = idle[0] ?? (takeMainCopyTurn(state) ? null : pool.leaseLeastBusy());
     if (lease === null) return null;
     leases.push(lease);
-    return await lease.executor.execute(queryAction(indexName, params, globalStats, partitionIds));
+    fork = patternWork.fork(1);
+    const result = await lease.executor.execute(
+      queryAction(indexName, params, globalStats, partitionIds, fork.shared)
+    );
+    fork.settle(result.patternWorkSpent ?? 0);
+    return result;
   } catch (err) {
+    if (isWorkCapError(err)) throw err;
+    fork?.settle(0);
     console.warn("Worker search failed, falling back to local:", err);
     return null;
   } finally {
@@ -28016,7 +29037,7 @@ function createWorkerOrchestrator(config, executor, indexRegistry, callbacks, ve
     segmentBuildConcurrency: (indexName) => segmentBuildConcurrency(state, indexName),
     holdUnbroadcastSegments: (indexName, segmentIds) => holdUnbroadcastSegments(state, indexName, segmentIds),
     releaseUnbroadcastSegments: (indexName, segmentIds) => releaseUnbroadcastSegments(state, indexName, segmentIds),
-    searchViaWorker: (indexName, params, globalStats, partitionIds) => searchViaWorker(state, indexName, params, globalStats, partitionIds),
+    searchViaWorker: (indexName, params, globalStats, partitionIds, patternWork) => searchViaWorker(state, indexName, params, globalStats, partitionIds, patternWork),
     hasWorkerPool: () => state.workerPool !== null,
     mainCopyQueries: () => state.mainCopyQueries ?? "lone",
     shareMainThread: () => {
@@ -28305,7 +29326,8 @@ function createEngineCore(config, hooks, capacityScope = "index") {
     analysisRebuild,
     indexState,
     mutationCtx,
-    rebalanceCtx
+    rebalanceCtx,
+    patternWorkCap: config?.patternWorkCap ?? DEFAULT_PATTERN_WORK_CAP
   };
 }
 
@@ -28404,6 +29426,7 @@ async function createEngineIndex(core, config, name, requestedConfig, creation =
   }
   const schema = validateSchema(requestedConfig.schema);
   const indexConfig = schema === requestedConfig.schema ? requestedConfig : { ...requestedConfig, schema };
+  requirePatternSearchFor(schema);
   validatePatternValueLimit(indexConfig.patternValueLimit);
   validateVectorPromotion(indexConfig.vectorPromotion);
   validateVectorStorage(indexConfig.vectorPromotion, core.filesystemDurability);
@@ -28434,10 +29457,10 @@ async function createEngineIndex(core, config, name, requestedConfig, creation =
     const fields = indexConfig.embedding.fields;
     if (typeof configuredAdapter === "string") {
       embeddingAdapterName = configuredAdapter;
-      const registered = core.embeddingAdapters.get(configuredAdapter);
-      if (registered !== void 0) {
+      const registered2 = core.embeddingAdapters.get(configuredAdapter);
+      if (registered2 !== void 0) {
         resolvedEmbeddingAdapter = validateEmbeddingConfig(
-          { fields, adapter: registered },
+          { fields, adapter: registered2 },
           indexConfig.schema,
           config?.embedding
         );
@@ -28791,9 +29814,30 @@ async function rollbackUpdatedDocument(ctx, indexName, docId, restoreDoc, origin
 
 // src/engine/mutations/insert-admission.ts
 function providedDocId(document2) {
+  if (document2 === null || typeof document2 !== "object") return void 0;
   const id = document2.id;
   return typeof id === "string" && id.length > 0 ? id : void 0;
 }
+function requireDocumentObject(document2) {
+  if (document2 !== null && typeof document2 === "object" && !Array.isArray(document2)) return;
+  const received = Array.isArray(document2) ? "a list" : document2 === null ? "null" : `a ${typeof document2}`;
+  throw new NarsilError(
+    ErrorCodes.DOC_VALIDATION_FAILED,
+    `Each document must be an object, while this entry is ${received}`,
+    {
+      received
+    }
+  );
+}
+function requireMatchingDocId(docId, document2) {
+  const embeddedDocId = providedDocId(document2);
+  if (embeddedDocId === void 0 || embeddedDocId === docId) return;
+  throw new NarsilError(
+    ErrorCodes.DOC_VALIDATION_FAILED,
+    `The call names document id "${docId}" while the document's own id field is "${embeddedDocId}", so the stored document would contradict the key that it is stored under`,
+    { docId, documentId: embeddedDocId }
+  );
+}
 function asBatchInsertError(err) {
   return err instanceof NarsilError ? err : new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, String(err));
 }
@@ -28904,15 +29948,8 @@ async function embedChunkDocuments(entry, documents, chunkStart, chunkEnd, signa
 async function insertDocument(ctx, indexName, document2, docId, options) {
   ctx.guardShutdown();
   const entry = ctx.requireIndex(indexName);
-  const embeddedDocId = providedDocId(document2);
-  if (docId !== void 0 && embeddedDocId !== void 0 && embeddedDocId !== docId) {
-    throw new NarsilError(
-      ErrorCodes.DOC_VALIDATION_FAILED,
-      `The call names document id "${docId}" while the document's own id field is "${embeddedDocId}", so the stored document would contradict the key that it is stored under`,
-      { docId, documentId: embeddedDocId }
-    );
-  }
-  const resolvedDocId = docId ?? embeddedDocId ?? ctx.idGenerator();
+  if (docId !== void 0) requireMatchingDocId(docId, document2);
+  const resolvedDocId = docId ?? providedDocId(document2) ?? ctx.idGenerator();
   validateDocId(resolvedDocId);
   await ctx.pluginRegistry.runHook("beforeInsert", { indexName, docId: resolvedDocId, document: document2 });
   if (entry.config.required && entry.config.required.length > 0) {
@@ -29149,6 +30186,7 @@ async function admitBatchDocuments(ctx, indexName, documents, failed) {
       if (chunkFailedIndexes.has(i)) continue;
       const docId = providedDocId(documents[i]) ?? ctx.idGenerator();
       try {
+        requireDocumentObject(documents[i]);
         validateDocId(docId);
         if (hasBeforeHook) {
           await ctx.pluginRegistry.runHook("beforeInsert", { indexName, docId, document: documents[i] });
@@ -29647,6 +30685,7 @@ async function insertDocumentBatch(ctx, indexName, documents, options) {
       if (chunkFailedIndexes.has(i)) continue;
       const batchDocId = providedDocId(documents[i]) ?? ctx.idGenerator();
       try {
+        requireDocumentObject(documents[i]);
         validateDocId(batchDocId);
         if (hasBeforeHook) {
           await ctx.pluginRegistry.runHook("beforeInsert", { indexName, docId: batchDocId, document: documents[i] });
@@ -29869,6 +30908,7 @@ async function settleUpdate(ctx, indexName, prepared) {
 async function prepareUpdate(ctx, indexName, entry, docId, document2) {
   ctx.guardShutdown();
   validateDocId(docId);
+  requireMatchingDocId(docId, document2);
   const manager = ctx.requireManager(indexName);
   if (ctx.pluginRegistry.hasHooks("beforeUpdate")) {
     await ctx.pluginRegistry.runHook("beforeUpdate", {
@@ -29978,6 +31018,22 @@ async function updateDocument(ctx, indexName, docId, document2, options) {
   ctx.checkHeapPressure(indexName);
   if (options?.wait === true) await awaitWriteVisibility(ctx, indexName);
 }
+function reportedDocIdOf(update) {
+  const docId = update !== null && typeof update === "object" ? update.docId : void 0;
+  return typeof docId === "string" ? docId : "";
+}
+function requireUpdateEntry(update) {
+  if (update !== null && typeof update === "object" && !Array.isArray(update)) {
+    const { docId, document: document2 } = update;
+    if (typeof docId === "string" && document2 !== null && typeof document2 === "object" && !Array.isArray(document2)) {
+      return { document: document2 };
+    }
+  }
+  throw new NarsilError(
+    ErrorCodes.DOC_VALIDATION_FAILED,
+    "Each entry of a batch update must be an object whose docId is a string and whose document is an object"
+  );
+}
 async function updateDocumentBatch(ctx, indexName, updates, options) {
   ctx.guardShutdown();
   const entry = ctx.requireIndex(indexName);
@@ -29990,10 +31046,13 @@ async function updateDocumentBatch(ctx, indexName, updates, options) {
     const chunkEnd = Math.min(chunkStart + BATCH_CHUNK_SIZE, updates.length);
     const prepared = [];
     for (let i = chunkStart; i < chunkEnd; i++) {
+      const update = updates[i];
+      const docId = reportedDocIdOf(update);
       try {
-        prepared.push(await prepareUpdate(ctx, indexName, entry, updates[i].docId, updates[i].document));
+        const { document: document2 } = requireUpdateEntry(update);
+        prepared.push(await prepareUpdate(ctx, indexName, entry, docId, document2));
       } catch (err) {
-        failed.push({ docId: updates[i].docId, error: asUpdateError(err) });
+        failed.push({ docId, error: asUpdateError(err) });
       }
     }
     const applies = prepared.map((update) => applyOfUpdate(ctx, indexName, update));
@@ -30978,6 +32037,9 @@ function requireValidTypoTolerance(params) {
 }
 
 // src/engine/query/shared.ts
+function withPatternWork(context) {
+  return { ...context, patternWork: createPatternWorkMeter(context.patternWorkCap) };
+}
 function partitionsFor(manager, partitionIds) {
   return partitionsIn(manager, partitionIds);
 }
@@ -31024,18 +32086,19 @@ function broadcastStatsForWorker(params, context, scoring) {
   }
   return pruneStatsToQueryTerms(scoring.globalStats, term, context.language, context.manager.analysis);
 }
-function searchOptionsFor(manager) {
+function searchOptionsFor(manager, patternWork) {
   return {
     bm25Params: manager.config.bm25,
     stopWords: manager.analysis.stopWords,
-    customTokenizer: manager.analysis.customTokenizer
+    customTokenizer: manager.analysis.customTokenizer,
+    patternWork
   };
 }
-function collectFilterDocIds(manager, params, schema, partitionIds) {
+function collectFilterDocIds(manager, params, schema, partitionIds, patternWork) {
   const filterDocIds = /* @__PURE__ */ new Set();
   if (!params.filters) return filterDocIds;
   for (const partition of partitionsFor(manager, partitionIds)) {
-    const partitionFiltered = partition.applyFilters(params.filters, schema);
+    const partitionFiltered = partition.applyFilters(params.filters, schema, patternWork);
     for (const docId of partitionFiltered) {
       filterDocIds.add(docId);
     }
@@ -31070,11 +32133,11 @@ function requireValidQueryOptions(params, config) {
   const strict = config.strict === true;
   requireValidTypoTolerance(params);
   requireSortableFields(params.sort, config.schema, strict);
-  requireValidQueryFilter(params.filters, config.schema, strict);
+  requireValidQueryFilter(params.filters, config.schema);
   requireUsableQueryFields(params, config.schema, strict);
 }
-function requireValidQueryFilter(filters, schema, strict = false) {
-  if (filters !== void 0) requireValidFilter(filters, flattenSchema(schema), strict);
+function requireValidQueryFilter(filters, schema) {
+  if (filters !== void 0) requireValidFilter(filters, flattenSchema(schema));
 }
 function requireVectorSearchable(params, context, needsVector) {
   if (!needsVector) return;
@@ -31110,8 +32173,9 @@ function firstIdAfter(sorted, anchor) {
   }
   return low;
 }
-function collectFilterMatches(partitions, filters, schema) {
-  const perPartition = partitions.map((partition) => partition.filterMatches(filters, schema));
+function collectFilterMatches(partitions, filters, schema, patternWorkCap) {
+  const meter = createPatternWorkMeter(patternWorkCap);
+  const perPartition = partitions.map((partition) => partition.filterMatches(filters, schema, meter));
   let total = 0;
   for (const matches of perPartition) total += matches.count;
   return { matchesFor: (partitionIndex) => perPartition[partitionIndex] ?? null, total };
@@ -31189,7 +32253,7 @@ function executeListDocuments(params, context) {
   const limit = clampListLimit(params.limit);
   const signature = sortSignatureOf(params.sort);
   requireSortableFields(params.sort, schema, context.strict === true);
-  requireValidQueryFilter(params.filters, schema, context.strict === true);
+  requireValidQueryFilter(params.filters, schema);
   const binding = listBindingOf(params.filters);
   let cursor = null;
   if (params.cursor !== void 0) {
@@ -31197,7 +32261,7 @@ function executeListDocuments(params, context) {
     requireMatchingCursor(cursor, params.cursor, signature, false, binding);
   }
   const partitions = context.partitionIds === void 0 ? manager.getAllPartitions() : context.partitionIds.map((partitionId) => manager.partitionAt(partitionId)).filter((partition) => partition !== void 0);
-  const filtered = params.filters === void 0 ? null : collectFilterMatches(partitions, params.filters, schema);
+  const filtered = params.filters === void 0 ? null : collectFilterMatches(partitions, params.filters, schema, context.patternWorkCap);
   const total = filtered === null ? countAcrossPartitions(manager, context.partitionIds, partitions) : filtered.total;
   const page = params.sort === void 0 || signature === null ? pageInIdOrder(partitions, cursor, filtered, limit, binding) : pageInSortOrder(partitions, cursor, filtered, limit, params.sort, signature, schema, binding);
   const projection = resolveProjection(params.document);
@@ -31564,7 +32628,7 @@ function executeSortedQueryPage(params, context, limit, offset, sortSignature) {
   const flatSchema = flattenSchema(schema);
   const fieldTypes = fields.map((field) => flatSchema[field]);
   const modes = sortModesOf(normalized);
-  const options = searchOptionsFor(manager);
+  const options = searchOptionsFor(manager, context.patternWork);
   const partitions = partitionsFor(manager, context.partitionIds);
   const partitionLimit = offset + limit + 1;
   const merged = [];
@@ -31765,7 +32829,7 @@ async function executeVectorSearch(params, context, limit, offset, cursorDepth =
   let filterDocIds;
   let filterPartitions;
   if (params.filters) {
-    filterDocIds = collectFilterDocIds(manager, params, config.schema, partitionIds);
+    filterDocIds = collectFilterDocIds(manager, params, config.schema, partitionIds, context.patternWork);
     if (filterDocIds.size === 0) {
       return { scored: [], totalMatched: 0 };
     }
@@ -31793,11 +32857,19 @@ async function textLeg(textOnlyParams, context) {
       indexName,
       textOnlyParams,
       broadcastStatsForWorker(textOnlyParams, context, scoring),
-      context.partitionIds
+      context.partitionIds,
+      context.patternWork
     );
     if (viaWorker) return viaWorker;
   }
-  return fanOutQuery(manager, textOnlyParams, language, config.schema, scoring, searchOptionsFor(manager));
+  return fanOutQuery(
+    manager,
+    textOnlyParams,
+    language,
+    config.schema,
+    scoring,
+    searchOptionsFor(manager, context.patternWork)
+  );
 }
 async function vectorLeg(vectorConfig, queryVector, context, filterDocIds, k) {
   const { manager } = context;
@@ -31823,7 +32895,7 @@ async function executeHybridSearch(params, context, limit, offset, cursorDepth =
   const fusion = resolveHybridFusion(params.hybrid);
   let filterDocIds;
   if (params.filters) {
-    filterDocIds = collectFilterDocIds(manager, params, config.schema, context.partitionIds);
+    filterDocIds = collectFilterDocIds(manager, params, config.schema, context.partitionIds, context.patternWork);
     if (filterDocIds.size === 0) {
       return { scored: [], totalMatched: 0 };
     }
@@ -31867,7 +32939,8 @@ function requireCursorDepth(cursor, signature, binding) {
   requireMatchingCursor(decoded, cursor, signature, true, binding);
   return decoded.depth ?? 0;
 }
-async function executeQuery(params, context) {
+async function executeQuery(params, callerContext) {
+  const context = withPatternWork(callerContext);
   const { manager, language, config, workerSearch, indexName } = context;
   const startTime = now();
   const limit = clampLimit(params.limit);
@@ -31913,11 +32986,24 @@ async function executeQuery(params, context) {
       fanOutResult = await executeHybridSearch(params, context, limit, offset, depth);
     } else {
       const scoring = scoringConfigFor(params, context);
-      const workerResult = workerSearch ? await workerSearch(indexName, params, broadcastStatsForWorker(params, context, scoring), context.partitionIds) : null;
+      const workerResult = workerSearch ? await workerSearch(
+        indexName,
+        params,
+        broadcastStatsForWorker(params, context, scoring),
+        context.partitionIds,
+        context.patternWork
+      ) : null;
       if (workerResult) {
         fanOutResult = workerResult;
       } else {
-        fanOutResult = await fanOutQuery(manager, params, language, config.schema, scoring, searchOptionsFor(manager));
+        fanOutResult = await fanOutQuery(
+          manager,
+          params,
+          language,
+          config.schema,
+          scoring,
+          searchOptionsFor(manager, context.patternWork)
+        );
       }
     }
     const needsFullHits = params.sort !== void 0 || params.group !== void 0 || params.pinned !== void 0 || params.searchAfter !== void 0;
@@ -32037,7 +33123,8 @@ async function executeQuery(params, context) {
     coverage: coverageFor(manager, context.partitionIds)
   };
 }
-async function executePreflight(params, context) {
+async function executePreflight(params, callerContext) {
+  const context = withPatternWork(callerContext);
   const { manager, language, config, workerSearch, indexName } = context;
   const startTime = now();
   requireKnownMode(params);
@@ -32063,12 +33150,18 @@ async function executePreflight(params, context) {
     countExact = result.matchedExact !== false;
   } else if (countsWithoutScores(params)) {
     totalMatched = fanOutMatchCount(manager, params, language, config.schema, {
-      searchOptions: searchOptionsFor(manager),
+      searchOptions: searchOptionsFor(manager, context.patternWork),
       partitionIds: context.partitionIds
     });
   } else {
     const scoring = scoringConfigFor(params, context);
-    const workerResult = workerSearch ? await workerSearch(indexName, params, broadcastStatsForWorker(params, context, scoring), context.partitionIds) : null;
+    const workerResult = workerSearch ? await workerSearch(
+      indexName,
+      params,
+      broadcastStatsForWorker(params, context, scoring),
+      context.partitionIds,
+      context.patternWork
+    ) : null;
     if (workerResult) {
       totalMatched = workerResult.totalMatched;
     } else {
@@ -32078,7 +33171,7 @@ async function executePreflight(params, context) {
         language,
         config.schema,
         scoring,
-        searchOptionsFor(manager)
+        searchOptionsFor(manager, context.patternWork)
       );
       totalMatched = fanOutResult.totalMatched;
     }
@@ -32226,7 +33319,8 @@ async function runEngineQuery(core, indexName, params, options) {
       indexName,
       broadcastStats: broadcastStatsFor(core, options),
       partitionIds: options?.partitionIds,
-      cursorBinding: queryBindingOf(params)
+      cursorBinding: queryBindingOf(params),
+      patternWorkCap: core.patternWorkCap
     });
     if (core.pluginRegistry.hasHooks("afterSearch")) {
       const observed = { ...result, hits: [...result.hits] };
@@ -32267,7 +33361,8 @@ async function runEnginePreflight(core, indexName, params, options) {
       indexName,
       broadcastStats: broadcastStatsFor(core, options),
       partitionIds: options?.partitionIds,
-      cursorBinding: queryBindingOf(params)
+      cursorBinding: queryBindingOf(params),
+      patternWorkCap: core.patternWorkCap
     });
     if (core.analysisRebuild.isStale(indexName)) {
       result.analysisStale = true;
@@ -32304,7 +33399,8 @@ async function runEngineListDocuments(core, indexName, params, partitionIds) {
       manager: core.requireManager(indexName),
       schema: entry.config.schema,
       strict: entry.config.strict,
-      partitionIds
+      partitionIds,
+      patternWorkCap: core.patternWorkCap
     });
   } finally {
     release();
@@ -32624,4 +33720,4 @@ async function createNarsil(config) {
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, VERSION, clearNormalizationCache, configureNormalizationCache, createNarsil, getLanguage, getNormalizationCacheSize, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isNarsilError, isSimdAvailable, registerLanguage, registerStopWords, registerTokenizer, resetNormalizationCache };
+export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, VERSION, clearNormalizationCache, configureNormalizationCache, createNarsil, getLanguage, getNormalizationCacheSize, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isNarsilError, isSimdAvailable, registerLanguage, registerPatternSearch, registerStopWords, registerTokenizer, resetNormalizationCache };