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

package/dist/{chunk-BEWOA4VV.mjs → chunk-M76V3OGJ.mjs}

@@ -1,11 +1,10 @@
-import { detectRuntime } from './chunk-AV4IJKD2.mjs';
-import { cloneProjected, everyValueFacetConfig, mergeFacets, computeFacets, tokenizeOptions, getNestedValue, visitTokens, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, getFlatSchema, textFieldsChanged, projectionKeepsField, setNestedValue, fnv1a, bitsetHas, createBitSet, kWayMerge, fuzzyPrefixOf, boundedLevenshtein, bitsetSet, tokenize, bitsetFromSet, getAllInternalDocIds, getFieldValueByInternalId, getOrCreateFieldNameIndex, tokenizeIterator, polygonContainment, requireValidOperands, bitsetAnd, bitsetOr, bitsetNot, requirePolygonRing, VINCENTY_CONVERGENCE_THRESHOLD, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-4VU5TWCR.mjs';
-import { flattenSchema, validateDocument, validateDocumentStrict, isQuantizationMode, isStorageMode, extractVectorFieldsFromSchema, isTextFieldType, VECTOR_PATTERN } from './chunk-6TGZG2TV.mjs';
-import { english } from './chunk-TGP5M5R7.mjs';
-import { SCRATCH_SLOTS_PER_THREAD_POOL, osqRecordBytes, openSharedVectorField, osqBitsOf, createVectorStore, DISK_STORAGE_BLOCK_BYTES, createOsqQuantizer, magnitude, createHNSWIndex, nativeStoreScratchBytes, createOrdinalFilter, isTombstoned, addToOrdinalFilter, ordinalFilterValues, nativeScoresOf, toScore, removeFromOrdinalFilter, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, requireWholeNeighbourLists, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, releaseLocksHeldBy, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS } from './chunk-THYRHHO2.mjs';
+import { getLanguage, detectRuntime } from './chunk-HWQLTLNG.mjs';
+import { cloneProjected, everyValueFacetConfig, mergeFacets, computeFacets, tokenizeOptions, getNestedValue, visitTokens, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, textFieldsChanged, projectionKeepsField, setNestedValue, fnv1a, bitsetHas, createBitSet, kWayMerge, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, bitsetSet, tokenize, bitsetFromSet, getAllInternalDocIds, getFieldValueByInternalId, getOrCreateFieldNameIndex, tokenizeIterator, polygonContainment, requireValidOperands, bitsetAnd, bitsetOr, bitsetNot, requirePolygonRing, VINCENTY_CONVERGENCE_THRESHOLD, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-LMO5TJUS.mjs';
+import { schemaFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, isQuantizationMode, isStorageMode, requireValidFieldTypes, extractVectorFieldsFromSchema, VECTOR_PATTERN, parsedTypeOf, isListBase } from './chunk-653BNMAF.mjs';
+import { SCRATCH_SLOTS_PER_THREAD_POOL, osqRecordBytes, openSharedVectorField, osqBitsOf, createVectorStore, DISK_STORAGE_BLOCK_BYTES, createOsqQuantizer, magnitude, createHNSWIndex, nativeStoreScratchBytes, createOrdinalFilter, isTombstoned, addToOrdinalFilter, ordinalFilterValues, nativeScoresOf, toScore, removeFromOrdinalFilter, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, requireWholeNeighbourLists, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, releaseLocksHeldBy, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS } from './chunk-YJDQ7NLA.mjs';
 import { noteFallback } from './chunk-YNVIUGF5.mjs';
 import { VALID_HNSW_METRICS } from './chunk-IFBKLBGB.mjs';
-import { compareCodePoints, toReducedSortValue, readSortField, compareComparableValues, defaultSortMode, SORT_VALUE_MAX_CODE_POINTS } from './chunk-YMZCMH5M.mjs';
+import { compareCodePoints, toReducedSortValue, readSortField, compareComparableValues, defaultSortMode, truncateSortString, SORT_VALUE_MAX_CODE_POINTS } from './chunk-OI42GWLR.mjs';
 import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
 import { totalmem } from 'os';
 import { getHeapStatistics } from 'v8';
@@ -59,20 +58,6 @@ function readHeapStatistics() {
   }
 }
 
-// src/languages/registry.ts
-var languages = /* @__PURE__ */ new Map();
-languages.set("english", english);
-function registerLanguage(module) {
-  languages.set(module.name, module);
-}
-function getLanguage(name) {
-  const lang = languages.get(name);
-  if (!lang) {
-    throw new NarsilError(ErrorCodes.LANGUAGE_NOT_SUPPORTED, `Language "${name}" is not registered`, { language: name });
-  }
-  return lang;
-}
-
 // src/analysis/registry.ts
 var tokenizers = /* @__PURE__ */ new Map();
 var stopWordSets = /* @__PURE__ */ new Map();
@@ -200,6 +185,9 @@ function metadataToWire(meta) {
       ...promotion.storage !== void 0 ? { storage: promotion.storage } : {}
     };
   }
+  if (meta.patternValueLimit !== void 0) {
+    wire.pattern_value_limit = meta.patternValueLimit;
+  }
   if (meta.indexUuid !== void 0) {
     wire.index_uuid = meta.indexUuid;
   }
@@ -321,6 +309,16 @@ function wireToMetadata(raw) {
       meta.vectorPromotion = restored;
     }
   }
+  if (raw.pattern_value_limit !== void 0) {
+    if (!isPositiveInteger(raw.pattern_value_limit)) {
+      throw new NarsilError(
+        ErrorCodes.CONFIG_INVALID,
+        `The pattern value limit in the index metadata is ${String(raw.pattern_value_limit)}, but the limit must be a whole number of code points`,
+        { patternValueLimit: String(raw.pattern_value_limit) }
+      );
+    }
+    meta.patternValueLimit = raw.pattern_value_limit;
+  }
   if (typeof raw.index_uuid === "string" && raw.index_uuid.length > 0) {
     meta.indexUuid = raw.index_uuid;
   }
@@ -415,6 +413,7 @@ function wireToPartition(raw) {
       fieldLengths: doc.field_lengths ?? {}
     };
   }
+  requireValidFieldTypes(raw.schema ?? {});
   dropStoredVectorValues(documents, raw.schema ?? {});
   const invertedIndex = {};
   for (const [token, list] of Object.entries(raw.inverted_index ?? {})) {
@@ -499,6 +498,7 @@ function validateHnswMetric2(value) {
   return void 0;
 }
 function storedDocumentsOf(raw) {
+  requireValidFieldTypes(raw.schema ?? {});
   const documents = {};
   for (const [docId, doc] of Object.entries(raw.documents ?? {})) {
     documents[docId] = {
@@ -1894,14 +1894,14 @@ function createNumericIndex() {
 }
 
 // src/core/partition/indexing.ts
-function ensureFieldIndex(state, fieldPath, fieldType) {
-  if ((fieldType === "number" || fieldType === "number[]") && !state.numericIndexes.has(fieldPath)) {
+function ensureFieldIndex(state, fieldPath, base) {
+  if ((base === "number" || base === "number[]") && !state.numericIndexes.has(fieldPath)) {
     state.numericIndexes.set(fieldPath, createNumericIndex());
-  } else if ((fieldType === "boolean" || fieldType === "boolean[]") && !state.booleanIndexes.has(fieldPath)) {
+  } else if ((base === "boolean" || base === "boolean[]") && !state.booleanIndexes.has(fieldPath)) {
     state.booleanIndexes.set(fieldPath, createBooleanIndex());
-  } else if ((fieldType === "enum" || fieldType === "enum[]") && !state.enumIndexes.has(fieldPath)) {
+  } else if ((base === "enum" || base === "enum[]") && !state.enumIndexes.has(fieldPath)) {
     state.enumIndexes.set(fieldPath, createEnumIndex());
-  } else if (fieldType === "geopoint" && !state.geoIndexes.has(fieldPath)) {
+  } else if (base === "geopoint" && !state.geoIndexes.has(fieldPath)) {
     state.geoIndexes.set(fieldPath, createGeoIndex());
   }
 }
@@ -2027,26 +2027,26 @@ function indexStringArrayField(state, internalId, fieldPath, arr, language, opti
   applySurfaceCounts(state, surfaceCounts, 1);
   tokensByField[fieldPath] = fieldTokenList;
 }
-function indexDocument(state, docId, document, flatSchema, language, options) {
+function indexDocument(state, docId, document, fields, language, options) {
   const fieldLengths = {};
   const tokensByField = {};
   const internalId = resolveInternalId(state, docId);
-  for (const [fieldPath, fieldType] of Object.entries(flatSchema)) {
+  for (const { path: fieldPath, base } of fields) {
     const value = getNestedValue(document, fieldPath);
     if (value === void 0 || value === null) continue;
-    ensureFieldIndex(state, fieldPath, fieldType);
-    if (isTextFieldType(fieldType)) {
+    ensureFieldIndex(state, fieldPath, base);
+    if (base === "string") {
       indexStringField(state, internalId, fieldPath, value, language, options, fieldLengths, tokensByField);
-    } else if (fieldType === "number") {
+    } else if (base === "number") {
       getOrCreateNumericIndex(state, fieldPath).insert(internalId, value);
-    } else if (fieldType === "boolean") {
+    } else if (base === "boolean") {
       getOrCreateBooleanIndex(state, fieldPath).insert(internalId, value);
-    } else if (fieldType === "enum") {
+    } else if (base === "enum") {
       state.enumIndexes.get(fieldPath)?.insert(internalId, value);
-    } else if (fieldType === "geopoint") {
+    } else if (base === "geopoint") {
       const geo = value;
       state.geoIndexes.get(fieldPath)?.insert(internalId, geo.lat, geo.lon);
-    } else if (fieldType === "string[]") {
+    } else if (base === "string[]") {
       indexStringArrayField(
         state,
         internalId,
@@ -2057,13 +2057,13 @@ function indexDocument(state, docId, document, flatSchema, language, options) {
         fieldLengths,
         tokensByField
       );
-    } else if (fieldType === "number[]") {
+    } else if (base === "number[]") {
       const numIdx = getOrCreateNumericIndex(state, fieldPath);
       for (const num of value) numIdx.insert(internalId, num);
-    } else if (fieldType === "boolean[]") {
+    } else if (base === "boolean[]") {
       const boolIdx = getOrCreateBooleanIndex(state, fieldPath);
       for (const b of value) boolIdx.insert(internalId, b);
-    } else if (fieldType === "enum[]") {
+    } else if (base === "enum[]") {
       const enumIdx = state.enumIndexes.get(fieldPath);
       if (enumIdx) {
         for (const e of value) enumIdx.insert(internalId, e);
@@ -2072,16 +2072,16 @@ function indexDocument(state, docId, document, flatSchema, language, options) {
   }
   return { fieldLengths, tokensByField };
 }
-function removeFromIndexes(state, docId, storedDoc, flatSchema, language, options) {
+function removeFromIndexes(state, docId, storedDoc, schemaFields, language, options) {
   const fieldLengths = {};
   const tokensByField = {};
   const fields = storedDoc.fields;
   const internalId = resolveInternalId(state, docId);
   const opts = tokenizeOptions(options);
-  for (const [fieldPath, fieldType] of Object.entries(flatSchema)) {
+  for (const { path: fieldPath, base } of schemaFields) {
     const value = getNestedValue(fields, fieldPath);
     if (value === void 0 || value === null) continue;
-    if (isTextFieldType(fieldType)) {
+    if (base === "string") {
       const result = tokenize(value, language, opts);
       fieldLengths[fieldPath] = result.tokens.length;
       const uniqueTokens = /* @__PURE__ */ new Set();
@@ -2096,15 +2096,15 @@ function removeFromIndexes(state, docId, storedDoc, flatSchema, language, option
       for (const token of uniqueTokens) state.invertedIdx.remove(token, internalId);
       applySurfaceCounts(state, surfaceCounts, -1);
       tokensByField[fieldPath] = fieldTokenList;
-    } else if (fieldType === "number") {
+    } else if (base === "number") {
       state.numericIndexes.get(fieldPath)?.remove(internalId, value);
-    } else if (fieldType === "boolean") {
+    } else if (base === "boolean") {
       state.booleanIndexes.get(fieldPath)?.remove(internalId, value);
-    } else if (fieldType === "enum") {
+    } else if (base === "enum") {
       state.enumIndexes.get(fieldPath)?.remove(internalId, value);
-    } else if (fieldType === "geopoint") {
+    } else if (base === "geopoint") {
       state.geoIndexes.get(fieldPath)?.remove(internalId);
-    } else if (fieldType === "string[]") {
+    } else if (base === "string[]") {
       const arr = value;
       const uniqueTokens = /* @__PURE__ */ new Set();
       const fieldTokenList = [];
@@ -2122,17 +2122,17 @@ function removeFromIndexes(state, docId, storedDoc, flatSchema, language, option
       for (const token of uniqueTokens) state.invertedIdx.remove(token, internalId);
       applySurfaceCounts(state, surfaceCounts, -1);
       tokensByField[fieldPath] = fieldTokenList;
-    } else if (fieldType === "number[]") {
+    } else if (base === "number[]") {
       const numIdx = state.numericIndexes.get(fieldPath);
       if (numIdx) {
         for (const num of value) numIdx.remove(internalId, num);
       }
-    } else if (fieldType === "boolean[]") {
+    } else if (base === "boolean[]") {
       const boolIdx = state.booleanIndexes.get(fieldPath);
       if (boolIdx) {
         for (const b of value) boolIdx.remove(internalId, b);
       }
-    } else if (fieldType === "enum[]") {
+    } else if (base === "enum[]") {
       const enumIdx = state.enumIndexes.get(fieldPath);
       if (enumIdx) {
         for (const e of value) enumIdx.remove(internalId, e);
@@ -2150,10 +2150,10 @@ function resolveInternalId2(state, docId) {
   }
   return internalId;
 }
-function updateFieldIndexOnly(state, docId, oldFields, newDoc, flatSchema) {
+function updateFieldIndexOnly(state, docId, oldFields, newDoc, fields) {
   const internalId = resolveInternalId2(state, docId);
-  for (const [fieldPath, fieldType] of Object.entries(flatSchema)) {
-    if (isTextFieldType(fieldType) || fieldType === "string[]") continue;
+  for (const { path: fieldPath, base: fieldType } of fields) {
+    if (isWordIndexedBase(fieldType)) continue;
     const oldVal = getNestedValue(oldFields, fieldPath);
     const newVal = getNestedValue(newDoc, fieldPath);
     if (oldVal === newVal) continue;
@@ -2486,6 +2486,14 @@ function applyGeoPolygonBitset(filter, geoIndex, capacity) {
 }
 
 // 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 requireKnownKeys(value, known, describe) {
@@ -2557,20 +2565,33 @@ function evaluateFieldFilter(fieldPath, filter, context) {
   if ("ne" in f && f.ne !== void 0) {
     bitsets.push(applyNeBitset(f.ne, getAllDocsBitset, capacity, getValue, fieldIndex));
   }
-  if ("gt" in f && f.gt !== void 0) {
+  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 ("lt" in f && f.lt !== void 0) {
+  if (typeof f.lt === "number") {
     bitsets.push(applyLtBitset(f.lt, getAllDocsBitset, capacity, getValue, fieldIndex));
   }
-  if ("gte" in f && f.gte !== void 0) {
+  if (typeof f.gte === "number") {
     bitsets.push(applyGteBitset(f.gte, getAllDocsBitset, capacity, getValue, fieldIndex));
   }
-  if ("lte" in f && f.lte !== void 0) {
+  if (typeof f.lte === "number") {
     bitsets.push(applyLteBitset(f.lte, getAllDocsBitset, capacity, getValue, fieldIndex));
   }
-  if ("between" in f && f.between !== void 0) {
-    bitsets.push(applyBetweenBitset(f.between, 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));
@@ -2632,240 +2653,6 @@ function resolveGeoIndex(fieldPath, fieldIndex) {
   return fieldIndex.index;
 }
 
-// src/core/partition/filters.ts
-var EMPTY_GEO_INDEX = {
-  radiusQuery: () => /* @__PURE__ */ new Set(),
-  polygonQuery: () => /* @__PURE__ */ new Set()
-};
-function buildFilterContext(state, schema) {
-  const flat = getFlatSchema(state, schema);
-  const fieldIndexes = {};
-  const capacity = state.docStore.internalIdCapacity();
-  for (const [fieldPath, fieldType] of Object.entries(flat)) {
-    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
-      };
-    }
-  }
-  let cachedAllDocIds = null;
-  let cachedAllDocIdsBitset = null;
-  return {
-    fieldTypes: flat,
-    fieldIndexes,
-    getFieldValue: (internalId, fieldPath) => getFieldValueByInternalId(state.docStore, internalId, fieldPath),
-    get allDocIds() {
-      if (!cachedAllDocIds) {
-        cachedAllDocIds = getAllInternalDocIds(state.docStore);
-      }
-      return cachedAllDocIds;
-    },
-    capacity,
-    get allDocIdsBitset() {
-      if (!cachedAllDocIdsBitset) {
-        cachedAllDocIdsBitset = bitsetFromSet(this.allDocIds, capacity);
-      }
-      return cachedAllDocIdsBitset;
-    }
-  };
-}
-function applyPartitionFilters(state, filters, schema) {
-  const context = buildFilterContext(state, schema);
-  const resultBitset = evaluateFilters(filters, context);
-  const resolver = state.docStore.resolver();
-  const externalResult = /* @__PURE__ */ new Set();
-  for (let wi = 0; wi < resultBitset.length; wi++) {
-    let word = resultBitset[wi];
-    if (word === 0) continue;
-    const base = wi << 5;
-    while (word !== 0) {
-      const tz = Math.clz32(word & -word) ^ 31;
-      const internalId = base + tz;
-      const externalId = resolver.toExternal(internalId);
-      if (externalId !== void 0) {
-        externalResult.add(externalId);
-      }
-      word &= word - 1;
-    }
-  }
-  return externalResult;
-}
-function applyPartitionFiltersBitset(state, filters, schema) {
-  const context = buildFilterContext(state, schema);
-  return evaluateFilters(filters, context);
-}
-function partitionFilterMatches(state, filters, schema) {
-  const accepted = applyPartitionFiltersBitset(state, filters, schema);
-  const docStore = state.docStore;
-  const resolver = docStore.resolver();
-  let count = 0;
-  for (let wordIndex = 0; wordIndex < accepted.length; wordIndex++) {
-    let word = accepted[wordIndex];
-    if (word === 0) continue;
-    const base = wordIndex << 5;
-    while (word !== 0) {
-      const trailingZeros = Math.clz32(word & -word) ^ 31;
-      if (resolver.toExternal(base + trailingZeros) !== void 0) count++;
-      word &= word - 1;
-    }
-  }
-  return {
-    count,
-    hasExternal(docId) {
-      const internalId = docStore.getInternalId(docId);
-      return internalId !== void 0 && bitsetHas(accepted, internalId);
-    },
-    hasInternal(internalId) {
-      return bitsetHas(accepted, internalId);
-    }
-  };
-}
-
-// src/core/partition/posting-columns.ts
-function postingColumns(list) {
-  const deletedDocs = list.deletedDocs;
-  return {
-    docIds: list.docIds,
-    termFrequencies: list.termFrequencies,
-    fieldNameIndices: list.fieldNameIndices,
-    deletedDocs,
-    hasDeleted: deletedDocs.size > 0,
-    count: list.length
-  };
-}
-
-// src/core/partition/matches.ts
-function markPostingList(matched, list, fieldNames, fields, filterBitset) {
-  const { docIds, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(list);
-  for (let pi = 0; pi < count; pi++) {
-    const internalId = docIds[pi];
-    if (hasDeleted && deletedDocs.has(internalId)) continue;
-    if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
-    if (fields && !fields.includes(fieldNames[fieldNameIndices[pi]])) continue;
-    bitsetSet(matched, internalId);
-  }
-}
-function searchFulltextMatches(state, params) {
-  const { queryTokens, prefixExpansion, fields, tolerance = 0, prefixLength = 2, exact = false, filterBitset } = params;
-  const fieldNames = state.fieldNameTable.names;
-  const matched = createBitSet(state.docStore.internalIdCapacity());
-  for (const qt of queryTokens) {
-    if (prefixExpansion && qt.token === prefixExpansion.token) {
-      const seen = /* @__PURE__ */ new Set();
-      for (const term of [qt.token, ...prefixExpansion.terms]) {
-        if (seen.has(term)) continue;
-        seen.add(term);
-        const postingList = state.invertedIdx.lookup(term);
-        if (postingList) markPostingList(matched, postingList, fieldNames, fields, filterBitset);
-      }
-      continue;
-    }
-    if (exact || tolerance === 0) {
-      const postingList = state.invertedIdx.lookup(qt.token);
-      if (postingList) markPostingList(matched, postingList, fieldNames, fields, filterBitset);
-      continue;
-    }
-    for (const match of state.invertedIdx.fuzzyLookup(qt.token, tolerance, prefixLength)) {
-      markPostingList(matched, match.postingList, fieldNames, fields, filterBitset);
-    }
-  }
-  const docStore = state.docStore;
-  const resolver = docStore.resolver();
-  let count = 0;
-  for (let wordIndex = 0; wordIndex < matched.length; wordIndex++) {
-    let word = matched[wordIndex];
-    if (word === 0) continue;
-    const base = wordIndex << 5;
-    while (word !== 0) {
-      const trailingZeros = Math.clz32(word & -word) ^ 31;
-      if (resolver.toExternal(base + trailingZeros) !== void 0) count++;
-      word &= word - 1;
-    }
-  }
-  return {
-    count,
-    hasExternal(docId) {
-      const internalId = docStore.getInternalId(docId);
-      return internalId !== void 0 && bitsetHas(matched, internalId);
-    },
-    hasInternal(internalId) {
-      return bitsetHas(matched, internalId);
-    },
-    matchedDocIds() {
-      const external = /* @__PURE__ */ new Set();
-      for (let wordIndex = 0; wordIndex < matched.length; wordIndex++) {
-        let word = matched[wordIndex];
-        if (word === 0) continue;
-        const base = wordIndex << 5;
-        while (word !== 0) {
-          const trailingZeros = Math.clz32(word & -word) ^ 31;
-          const externalId = resolver.toExternal(base + trailingZeros);
-          if (externalId !== void 0) external.add(externalId);
-          word &= word - 1;
-        }
-      }
-      return external;
-    },
-    ordinalBitset() {
-      return matched;
-    }
-  };
-}
-
 // src/core/partition/constants.ts
 var TARGET_BLOCK_ENTRIES = 128;
 var PRUNING_REJECTION_SLACK = 1e-12;
@@ -2974,8 +2761,9 @@ function grow(length, wanted) {
   return next;
 }
 function kindForFieldType(fieldType) {
-  if (fieldType === "number") return "number";
-  if (fieldType === "boolean") return "boolean";
+  const base = parsedTypeOf(fieldType)?.base;
+  if (base === "number") return "number";
+  if (base === "boolean") return "boolean";
   return "mixed";
 }
 function createValueStore(initialKind) {
@@ -3098,7 +2886,8 @@ function createValueStore(initialKind) {
 
 // src/core/partition/sort-columns/index.ts
 function mayHoldList(fieldType) {
-  return fieldType === void 0 || fieldType.endsWith("[]");
+  const parsed = parsedTypeOf(fieldType);
+  return parsed === void 0 || isListBase(parsed.base);
 }
 function columnKeyOf(field, fieldType, mode) {
   return mayHoldList(fieldType) ? `${mode}:${field}` : `value:${field}`;
@@ -3234,6 +3023,48 @@ function createSortColumnSet(docStore) {
   };
 }
 
+// src/core/partition/sort-columns/range.ts
+function withinBounds(value, bounds) {
+  if (value === null) return false;
+  if (bounds.lower !== null) {
+    const comparison = compareComparableValues(value, bounds.lower, "asc");
+    if (comparison < 0 || comparison === 0 && !bounds.lowerInclusive) return false;
+  }
+  if (bounds.upper !== null) {
+    const comparison = compareComparableValues(value, bounds.upper, "asc");
+    if (comparison > 0 || comparison === 0 && !bounds.upperInclusive) return false;
+  }
+  return true;
+}
+function selectTextRange(column, requested, capacity, isLive2) {
+  const bounds = {
+    ...requested,
+    lower: requested.lower === null ? null : truncateSortString(requested.lower),
+    upper: requested.upper === null ? null : truncateSortString(requested.upper)
+  };
+  const order = column.order;
+  const ordered = order.ordered;
+  const result = createBitSet(capacity);
+  let start = 0;
+  if (bounds.lower !== null) {
+    const lowerRank = rankOfValue(order, bounds.lower);
+    start = column.seek(bounds.lowerInclusive ? lowerRank : lowerRank + 1, "asc");
+  }
+  let end = ordered.length;
+  if (bounds.upper !== null) {
+    const upperRank = rankOfValue(order, bounds.upper);
+    end = column.seek(bounds.upperInclusive ? upperRank + 1 : upperRank, "asc");
+  }
+  for (let position = start; position < end; position++) {
+    const internalId = ordered[position];
+    if (!column.isDirty(internalId) && isLive2(internalId)) bitsetSet(result, internalId);
+  }
+  for (const internalId of column.dirtyStream().present) {
+    if (withinBounds(column.valueOf(internalId), bounds)) bitsetSet(result, internalId);
+  }
+  return result;
+}
+
 // src/core/partition/sort-columns/select.ts
 function rankOrdersAfter(rank, other, direction) {
   if (rank === MISSING_RANK) return other !== MISSING_RANK;
@@ -3354,85 +3185,326 @@ function createStream(column, direction, anchorRank) {
         return dirtyId;
       }
     }
-    return nextMissing();
+    return nextMissing();
+  };
+}
+function selectSortedPage(state, request) {
+  const { fields, directions, fieldTypes, modes, limit, anchorKey, anchorId, matches } = request;
+  if (limit <= 0 || fields.length === 0) return [];
+  const set = state.sortColumns;
+  if (set === null) return [];
+  const columns = fields.map(
+    (field, index) => set.column(field, fieldTypes[index], modes[index] ?? defaultSortMode(directions[index] ?? "asc"))
+  );
+  const resolver = state.docStore.resolver();
+  const leading = columns[0];
+  const leadingDirection = directions[0];
+  const anchorRank = anchorKey === null || anchorId === null ? null : rankOfValue(leading.order, anchorKey[0] ?? null);
+  const next = createStream(leading, leadingDirection, anchorRank);
+  const page = [];
+  for (; ; ) {
+    const internalId = next();
+    if (internalId === -1) break;
+    if (matches !== null && !matches.hasInternal(internalId)) continue;
+    const externalId = resolver.toExternal(internalId);
+    if (externalId === void 0) continue;
+    const leadingRank = leading.rankOf(internalId);
+    if (page.length === limit && rankOrdersAfter(leadingRank, page[limit - 1].leadingRank, leadingDirection)) {
+      break;
+    }
+    const key = new Array(columns.length);
+    for (let i = 0; i < columns.length; i++) key[i] = columns[i].valueOf(internalId);
+    const candidate = { internalId, externalId, leadingRank, key };
+    if (anchorKey !== null && anchorId !== null) {
+      if (compareWithAnchor(columns, directions, candidate, anchorKey, anchorId) <= 0) continue;
+    }
+    if (page.length === limit) {
+      if (compareCandidates(columns, directions, candidate, page[limit - 1]) >= 0) continue;
+      page.pop();
+    }
+    insertOrdered(page, candidate, columns, directions);
+  }
+  return page.map((entry) => ({ id: entry.externalId, key: entry.key }));
+}
+
+// src/core/partition/sorting.ts
+function ensureColumns(state) {
+  if (state.sortColumns === null) {
+    state.sortColumns = createSortColumnSet(state.docStore);
+  }
+  return state.sortColumns;
+}
+function textRangeBitsetOf(state, fieldPath, fieldType, bounds, capacity) {
+  const column = ensureColumns(state).column(fieldPath, fieldType, "min");
+  const resolver = state.docStore.resolver();
+  return selectTextRange(column, bounds, capacity, (internalId) => resolver.toExternal(internalId) !== void 0);
+}
+function sortedPageOf(state, request) {
+  ensureColumns(state);
+  return selectSortedPage(state, request);
+}
+function sortValuesOf(state, docId, fields, fieldTypes, modes) {
+  const set = state.sortColumns;
+  const internalId = state.docStore.getInternalId(docId);
+  const stored = state.docStore.get(docId);
+  const key = new Array(fields.length);
+  for (let i = 0; i < fields.length; i++) {
+    const mode = modes[i] ?? "min";
+    if (set !== null && internalId !== void 0 && set.holds(fields[i], fieldTypes[i], mode)) {
+      key[i] = set.column(fields[i], fieldTypes[i], mode).valueOf(internalId);
+      continue;
+    }
+    key[i] = stored === void 0 ? null : toReducedSortValue(readSortField(stored.fields, fields[i]), mode);
+  }
+  return key;
+}
+function recordSortValues(state, internalId, document) {
+  state.sortColumns?.record(internalId, document);
+}
+function forgetSortValues(state, internalId) {
+  if (internalId === void 0) return;
+  state.sortColumns?.forget(internalId);
+}
+function refreshSortColumns(state) {
+  state.sortColumns?.refresh();
+}
+function sortColumnBytes(state) {
+  return state.sortColumns === null ? 0 : state.sortColumns.estimateBytes();
+}
+
+// src/core/partition/filters.ts
+var EMPTY_GEO_INDEX = {
+  radiusQuery: () => /* @__PURE__ */ new Set(),
+  polygonQuery: () => /* @__PURE__ */ new Set()
+};
+function buildFilterContext(state, schema) {
+  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
+      };
+    }
+  }
+  let cachedAllDocIds = null;
+  let cachedAllDocIdsBitset = null;
+  return {
+    fieldTypes: flat,
+    fieldIndexes,
+    getFieldValue: (internalId, fieldPath) => getFieldValueByInternalId(state.docStore, internalId, fieldPath),
+    textRangeBitset: (fieldPath, bounds) => textRangeBitsetOf(state, fieldPath, flat[fieldPath], bounds, capacity),
+    get allDocIds() {
+      if (!cachedAllDocIds) {
+        cachedAllDocIds = getAllInternalDocIds(state.docStore);
+      }
+      return cachedAllDocIds;
+    },
+    capacity,
+    get allDocIdsBitset() {
+      if (!cachedAllDocIdsBitset) {
+        cachedAllDocIdsBitset = bitsetFromSet(this.allDocIds, capacity);
+      }
+      return cachedAllDocIdsBitset;
+    }
   };
 }
-function selectSortedPage(state, request) {
-  const { fields, directions, fieldTypes, modes, limit, anchorKey, anchorId, matches } = request;
-  if (limit <= 0 || fields.length === 0) return [];
-  const set = state.sortColumns;
-  if (set === null) return [];
-  const columns = fields.map(
-    (field, index) => set.column(field, fieldTypes[index], modes[index] ?? defaultSortMode(directions[index] ?? "asc"))
-  );
+function applyPartitionFilters(state, filters, schema) {
+  const context = buildFilterContext(state, schema);
+  const resultBitset = evaluateFilters(filters, context);
   const resolver = state.docStore.resolver();
-  const leading = columns[0];
-  const leadingDirection = directions[0];
-  const anchorRank = anchorKey === null || anchorId === null ? null : rankOfValue(leading.order, anchorKey[0] ?? null);
-  const next = createStream(leading, leadingDirection, anchorRank);
-  const page = [];
-  for (; ; ) {
-    const internalId = next();
-    if (internalId === -1) break;
-    if (matches !== null && !matches.hasInternal(internalId)) continue;
-    const externalId = resolver.toExternal(internalId);
-    if (externalId === void 0) continue;
-    const leadingRank = leading.rankOf(internalId);
-    if (page.length === limit && rankOrdersAfter(leadingRank, page[limit - 1].leadingRank, leadingDirection)) {
-      break;
-    }
-    const key = new Array(columns.length);
-    for (let i = 0; i < columns.length; i++) key[i] = columns[i].valueOf(internalId);
-    const candidate = { internalId, externalId, leadingRank, key };
-    if (anchorKey !== null && anchorId !== null) {
-      if (compareWithAnchor(columns, directions, candidate, anchorKey, anchorId) <= 0) continue;
+  const externalResult = /* @__PURE__ */ new Set();
+  for (let wi = 0; wi < resultBitset.length; wi++) {
+    let word = resultBitset[wi];
+    if (word === 0) continue;
+    const base = wi << 5;
+    while (word !== 0) {
+      const tz = Math.clz32(word & -word) ^ 31;
+      const internalId = base + tz;
+      const externalId = resolver.toExternal(internalId);
+      if (externalId !== void 0) {
+        externalResult.add(externalId);
+      }
+      word &= word - 1;
     }
-    if (page.length === limit) {
-      if (compareCandidates(columns, directions, candidate, page[limit - 1]) >= 0) continue;
-      page.pop();
+  }
+  return externalResult;
+}
+function applyPartitionFiltersBitset(state, filters, schema) {
+  const context = buildFilterContext(state, schema);
+  return evaluateFilters(filters, context);
+}
+function partitionFilterMatches(state, filters, schema) {
+  const accepted = applyPartitionFiltersBitset(state, filters, schema);
+  const docStore = state.docStore;
+  const resolver = docStore.resolver();
+  let count = 0;
+  for (let wordIndex = 0; wordIndex < accepted.length; wordIndex++) {
+    let word = accepted[wordIndex];
+    if (word === 0) continue;
+    const base = wordIndex << 5;
+    while (word !== 0) {
+      const trailingZeros = Math.clz32(word & -word) ^ 31;
+      if (resolver.toExternal(base + trailingZeros) !== void 0) count++;
+      word &= word - 1;
     }
-    insertOrdered(page, candidate, columns, directions);
   }
-  return page.map((entry) => ({ id: entry.externalId, key: entry.key }));
+  return {
+    count,
+    hasExternal(docId) {
+      const internalId = docStore.getInternalId(docId);
+      return internalId !== void 0 && bitsetHas(accepted, internalId);
+    },
+    hasInternal(internalId) {
+      return bitsetHas(accepted, internalId);
+    }
+  };
 }
 
-// src/core/partition/sorting.ts
-function ensureColumns(state) {
-  if (state.sortColumns === null) {
-    state.sortColumns = createSortColumnSet(state.docStore);
-  }
+// src/core/partition/posting-columns.ts
+function postingColumns(list) {
+  const deletedDocs = list.deletedDocs;
+  return {
+    docIds: list.docIds,
+    termFrequencies: list.termFrequencies,
+    fieldNameIndices: list.fieldNameIndices,
+    deletedDocs,
+    hasDeleted: deletedDocs.size > 0,
+    count: list.length
+  };
 }
-function sortedPageOf(state, request) {
-  ensureColumns(state);
-  return selectSortedPage(state, request);
+
+// src/core/partition/matches.ts
+function markPostingList(matched, list, fieldNames, fields, filterBitset) {
+  const { docIds, fieldNameIndices, deletedDocs, hasDeleted, count } = postingColumns(list);
+  for (let pi = 0; pi < count; pi++) {
+    const internalId = docIds[pi];
+    if (hasDeleted && deletedDocs.has(internalId)) continue;
+    if (filterBitset && !bitsetHas(filterBitset, internalId)) continue;
+    if (fields && !fields.includes(fieldNames[fieldNameIndices[pi]])) continue;
+    bitsetSet(matched, internalId);
+  }
 }
-function sortValuesOf(state, docId, fields, fieldTypes, modes) {
-  const set = state.sortColumns;
-  const internalId = state.docStore.getInternalId(docId);
-  const stored = state.docStore.get(docId);
-  const key = new Array(fields.length);
-  for (let i = 0; i < fields.length; i++) {
-    const mode = modes[i] ?? "min";
-    if (set !== null && internalId !== void 0 && set.holds(fields[i], fieldTypes[i], mode)) {
-      key[i] = set.column(fields[i], fieldTypes[i], mode).valueOf(internalId);
+function searchFulltextMatches(state, params) {
+  const { queryTokens, prefixExpansion, fields, tolerance = 0, prefixLength = 2, exact = false, filterBitset } = params;
+  const fieldNames = state.fieldNameTable.names;
+  const matched = createBitSet(state.docStore.internalIdCapacity());
+  for (const qt of queryTokens) {
+    if (prefixExpansion && qt.token === prefixExpansion.token) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const term of [qt.token, ...prefixExpansion.terms]) {
+        if (seen.has(term)) continue;
+        seen.add(term);
+        const postingList = state.invertedIdx.lookup(term);
+        if (postingList) markPostingList(matched, postingList, fieldNames, fields, filterBitset);
+      }
       continue;
     }
-    key[i] = stored === void 0 ? null : toReducedSortValue(readSortField(stored.fields, fields[i]), mode);
+    if (exact || tolerance === 0) {
+      const postingList = state.invertedIdx.lookup(qt.token);
+      if (postingList) markPostingList(matched, postingList, fieldNames, fields, filterBitset);
+      continue;
+    }
+    for (const match of state.invertedIdx.fuzzyLookup(qt.token, tolerance, prefixLength)) {
+      markPostingList(matched, match.postingList, fieldNames, fields, filterBitset);
+    }
   }
-  return key;
-}
-function recordSortValues(state, internalId, document) {
-  state.sortColumns?.record(internalId, document);
-}
-function forgetSortValues(state, internalId) {
-  if (internalId === void 0) return;
-  state.sortColumns?.forget(internalId);
-}
-function refreshSortColumns(state) {
-  state.sortColumns?.refresh();
-}
-function sortColumnBytes(state) {
-  return state.sortColumns === null ? 0 : state.sortColumns.estimateBytes();
+  const docStore = state.docStore;
+  const resolver = docStore.resolver();
+  let count = 0;
+  for (let wordIndex = 0; wordIndex < matched.length; wordIndex++) {
+    let word = matched[wordIndex];
+    if (word === 0) continue;
+    const base = wordIndex << 5;
+    while (word !== 0) {
+      const trailingZeros = Math.clz32(word & -word) ^ 31;
+      if (resolver.toExternal(base + trailingZeros) !== void 0) count++;
+      word &= word - 1;
+    }
+  }
+  return {
+    count,
+    hasExternal(docId) {
+      const internalId = docStore.getInternalId(docId);
+      return internalId !== void 0 && bitsetHas(matched, internalId);
+    },
+    hasInternal(internalId) {
+      return bitsetHas(matched, internalId);
+    },
+    matchedDocIds() {
+      const external = /* @__PURE__ */ new Set();
+      for (let wordIndex = 0; wordIndex < matched.length; wordIndex++) {
+        let word = matched[wordIndex];
+        if (word === 0) continue;
+        const base = wordIndex << 5;
+        while (word !== 0) {
+          const trailingZeros = Math.clz32(word & -word) ^ 31;
+          const externalId = resolver.toExternal(base + trailingZeros);
+          if (externalId !== void 0) external.add(externalId);
+          word &= word - 1;
+        }
+      }
+      return external;
+    },
+    ordinalBitset() {
+      return matched;
+    }
+  };
 }
 
 // src/core/partition/memory.ts
@@ -3607,11 +3679,11 @@ var EMPTY_STATS = {
   averageFieldLengths: {},
   docFrequencies: {}
 };
-function textFieldsOf(flatSchema) {
-  return Object.entries(flatSchema).filter(([, fieldType]) => isTextFieldType(fieldType) || fieldType === "string[]");
+function textFieldsOf(fields) {
+  return fields.filter((field) => isWordIndexedBase(field.base));
 }
 function rebuildTextIndex(state, schema, language, options) {
-  const textFields = textFieldsOf(getFlatSchema(state, schema));
+  const textFields = textFieldsOf(schemaFieldsOf(schema));
   state.invertedIdx.clear();
   state.surfaceRegistry.clear();
   state.stats.deserialize(EMPTY_STATS);
@@ -3623,10 +3695,10 @@ function rebuildTextIndex(state, schema, language, options) {
       const fields = stored.fields;
       const fieldLengths = {};
       const tokensByField = {};
-      for (const [fieldPath, fieldType] of textFields) {
+      for (const { path: fieldPath, base } of textFields) {
         const value = getNestedValue(fields, fieldPath);
         if (value === void 0 || value === null) continue;
-        if (isTextFieldType(fieldType)) {
+        if (base === "string") {
           indexStringField(
             state,
             internalId,
@@ -5303,18 +5375,17 @@ function createPartitionIndex(partitionId, trackPositions = true) {
         );
       }
       if (options?.validate !== false) {
-        validateDocument(document, schema);
+        validateDocument(document, schema, options?.patternValueLimit);
         if (options?.strict) {
           validateDocumentStrict(document, schema);
         }
       }
       const internalId = state.docStore.ensureInternalId(docId);
-      const flatSchema = getFlatSchema(state, schema);
       const { fieldLengths, tokensByField } = indexDocument(
         state,
         docId,
         document,
-        flatSchema,
+        schemaFieldsOf(schema),
         language,
         options
       );
@@ -5334,8 +5405,14 @@ function createPartitionIndex(partitionId, trackPositions = true) {
           partitionId
         });
       }
-      const flatSchema = getFlatSchema(state, schema);
-      const { fieldLengths, tokensByField } = removeFromIndexes(state, docId, stored, flatSchema, language, options);
+      const { fieldLengths, tokensByField } = removeFromIndexes(
+        state,
+        docId,
+        stored,
+        schemaFieldsOf(schema),
+        language,
+        options
+      );
       const internalId = state.docStore.getInternalId(docId);
       state.docStore.remove(docId);
       state.stats.removeDocument(fieldLengths, tokensByField);
@@ -5366,19 +5443,19 @@ function createPartitionIndex(partitionId, trackPositions = true) {
         });
       }
       if (options?.validate !== false) {
-        validateDocument(document, schema);
+        validateDocument(document, schema, options?.patternValueLimit);
         if (options?.strict) {
           validateDocumentStrict(document, schema);
         }
       }
-      const flatSchema = getFlatSchema(state, schema);
-      const needsTextReindex = textFieldsChanged(stored.fields, document, flatSchema);
+      const fields = schemaFieldsOf(schema);
+      const needsTextReindex = textFieldsChanged(stored.fields, document, fields);
       if (needsTextReindex) {
         const { fieldLengths: oldFieldLengths, tokensByField: oldTokens } = removeFromIndexes(
           state,
           docId,
           stored,
-          flatSchema,
+          fields,
           language,
           options
         );
@@ -5391,7 +5468,7 @@ function createPartitionIndex(partitionId, trackPositions = true) {
           state,
           docId,
           document,
-          flatSchema,
+          fields,
           language,
           options
         );
@@ -5399,7 +5476,7 @@ function createPartitionIndex(partitionId, trackPositions = true) {
         state.stats.addDocument(newFieldLengths, newTokens);
         recordSortValues(state, internalId, document);
       } else {
-        updateFieldIndexOnly(state, docId, stored.fields, document, flatSchema);
+        updateFieldIndexOnly(state, docId, stored.fields, document, fields);
         state.docStore.store(docId, document, stored.fieldLengths);
         const internalId = state.docStore.getInternalId(docId);
         if (internalId !== void 0) recordSortValues(state, internalId, document);
@@ -6164,9 +6241,11 @@ function resolvePartitionInsertOptions(config, analysis, options) {
   const applyStrict = config.strict === true;
   const applyAnalyzer = analysis.stopWords !== void 0 || analysis.customTokenizer !== void 0;
   const applySurfaces = config.surfaceForms !== false;
-  if (!applyStrict && !applyAnalyzer && !applySurfaces) return options;
+  const applyPatternLimit = config.patternValueLimit !== void 0;
+  if (!applyStrict && !applyAnalyzer && !applySurfaces && !applyPatternLimit) return options;
   const resolved = { ...options };
   if (applyStrict) resolved.strict = true;
+  if (applyPatternLimit) resolved.patternValueLimit = config.patternValueLimit;
   if (applyAnalyzer) {
     resolved.stopWordOverride = options?.stopWordOverride ?? analysis.stopWords;
     resolved.customTokenizer = options?.customTokenizer ?? analysis.customTokenizer;
@@ -6175,6 +6254,44 @@ function resolvePartitionInsertOptions(config, analysis, options) {
   return resolved;
 }
 
+// src/partitioning/manager/capacity.ts
+function createCapacityChecks(source) {
+  const { indexName, config } = source;
+  return {
+    assertCapacity(pendingWrites = 0, partitionCountCap) {
+      const maxDocsPerPartition = config.partitions?.maxDocsPerPartition;
+      if (maxDocsPerPartition === void 0) return;
+      const partitionCount = source.partitionCount();
+      const effectivePartitionCount = partitionCountCap === void 0 ? partitionCount : Math.min(partitionCount, partitionCountCap);
+      const totalCapacity = maxDocsPerPartition * effectivePartitionCount;
+      const currentCount = source.documentCount() + pendingWrites;
+      if (currentCount < totalCapacity) return;
+      throw new NarsilError(
+        ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
+        `Index "${indexName}" has reached its capacity of ${totalCapacity} documents (${maxDocsPerPartition} per partition \xD7 ${effectivePartitionCount} partitions)`,
+        {
+          indexName,
+          currentCount,
+          totalCapacity,
+          maxDocsPerPartition,
+          partitionCount: effectivePartitionCount
+        }
+      );
+    },
+    assertPartitionCapacity(partitionId, pendingWrites = 0) {
+      const maxDocsPerPartition = config.partitions?.maxDocsPerPartition;
+      if (maxDocsPerPartition === void 0) return;
+      const currentCount = source.getPartition(partitionId).count() + pendingWrites;
+      if (currentCount < maxDocsPerPartition) return;
+      throw new NarsilError(
+        ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
+        `Partition ${partitionId} of index "${indexName}" has reached its capacity of ${maxDocsPerPartition} documents`,
+        { indexName, partitionId, currentCount, maxDocsPerPartition }
+      );
+    }
+  };
+}
+
 // src/partitioning/manager/index.ts
 function createPartitionManager(indexName, config, language, router, initialPartitionCount, vectorIndexes) {
   const count = initialPartitionCount ?? 1;
@@ -6302,27 +6419,17 @@ function createPartitionManager(indexName, config, language, router, initialPart
       }
       partitions.length = newCount;
     },
-    assertCapacity(pendingWrites = 0, partitionCountCap) {
-      const currentMaxDocs = config.partitions?.maxDocsPerPartition;
-      if (currentMaxDocs === void 0) return;
-      const effectivePartitionCount = partitionCountCap === void 0 ? partitions.length : Math.min(partitions.length, partitionCountCap);
-      const totalCapacity = currentMaxDocs * effectivePartitionCount;
-      if (manager.countDocuments() + pendingWrites >= totalCapacity) {
-        throw new NarsilError(
-          ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
-          `Index "${indexName}" has reached its capacity of ${totalCapacity} documents (${currentMaxDocs} per partition \xD7 ${effectivePartitionCount} partitions)`,
-          {
-            indexName,
-            currentCount: docPartitionMap.size + pendingWrites,
-            totalCapacity,
-            maxDocsPerPartition: currentMaxDocs,
-            partitionCount: effectivePartitionCount
-          }
-        );
-      }
+    ...createCapacityChecks({
+      indexName,
+      config,
+      partitionCount: () => partitions.length,
+      documentCount: () => manager.countDocuments(),
+      getPartition: (partitionId) => manager.getPartition(partitionId)
+    }),
+    routePartition(docId) {
+      return router.route(docId, partitions.length);
     },
     insert(docId, document, options) {
-      manager.assertCapacity();
       const pid = router.route(docId, partitions.length);
       const insertOpts = resolveInsertOptions(options);
       partitions[pid].insert(docId, document, config.schema, language, insertOpts);
@@ -10364,7 +10471,7 @@ function refuseRepeatedDocIds(documents) {
 function validateAsAnInsertDoes(documents, schema, options) {
   if (options?.validate === false) return;
   for (const { document } of documents) {
-    validateDocument(document, schema);
+    validateDocument(document, schema, options?.patternValueLimit);
     if (options?.strict) validateDocumentStrict(document, schema);
   }
 }
@@ -10574,7 +10681,7 @@ var FieldLengths = class {
 function buildSegmentPayload(documents, schema, language, options, trackPositions) {
   refuseRepeatedDocIds(documents);
   validateAsAnInsertDoes(documents, schema, options);
-  const fields = Object.entries(flattenSchema(schema));
+  const fields = schemaFieldsOf(schema);
   const tokenizing = tokenizeOptions(options);
   const postings = new TextPostings(trackPositions);
   const surfaces = new SurfaceCounts();
@@ -10592,10 +10699,10 @@ function buildSegmentPayload(documents, schema, language, options, trackPosition
   };
   for (let ordinal = 0; ordinal < documents.length; ordinal++) {
     const document = documents[ordinal].document;
-    for (const [fieldPath, fieldType] of fields) {
+    for (const { path: fieldPath, base: fieldType } of fields) {
       const value = getNestedValue(document, fieldPath);
       if (value === void 0 || value === null) continue;
-      if (fieldType !== "string" && fieldType !== "string[]") {
+      if (!isWordIndexedBase(fieldType)) {
         indexFilterValue(filters, ordinal, fieldPath, fieldType, value);
         continue;
       }
@@ -11159,4 +11266,4 @@ function createDirectExecutor(options) {
   };
 }
 
-export { CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VECTOR_FILE_MAX_VECTORS, buildSegmentPayload, countDead, createCompositePartition, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeVectorFilePayload, decodeVectorGraphPayload, decodeVectorIndexParts, deserializeMetadata, deserializePayloadV1, deserializePayloadV2, documentsOfPayloadV2, encodeSegmentState, freezeSegmentShared, generateId, getLanguage, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, mergeFrozenSegments, missingWorkerEntry, nodeThreadId, readHeapStatistics, registerLanguage, registerStopWords, registerTokenizer, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, serializeMetadata, spawnNodeWorker, splitWorkerBudget, workerResourceLimits };
+export { CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VECTOR_FILE_MAX_VECTORS, buildSegmentPayload, countDead, createCompositePartition, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeVectorFilePayload, decodeVectorGraphPayload, decodeVectorIndexParts, deserializeMetadata, deserializePayloadV1, deserializePayloadV2, documentsOfPayloadV2, encodeSegmentState, freezeSegmentShared, generateId, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, mergeFrozenSegments, missingWorkerEntry, nodeThreadId, readHeapStatistics, registerStopWords, registerTokenizer, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, serializeMetadata, spawnNodeWorker, splitWorkerBudget, workerResourceLimits };