@delali/narsil 0.3.1-next.73 → 0.3.1-next.75

package/dist/{chunk-LPBWCHBE.mjs → chunk-BT6BI4GV.mjs}

@@ -1,5 +1,5 @@
-import { MAX_SORT_FIELDS } from './chunk-AK3BLGCI.mjs';
-import { nativeSearchCoreIsEnabled, loadNativeCore } from './chunk-PU43WDY4.mjs';
+import { MAX_FILTER_DEPTH, MAX_SORT_FIELDS } from './chunk-V3B24XR7.mjs';
+import { nativeSearchCoreIsEnabled, loadNativeCore } from './chunk-2E35UM3G.mjs';
 import { NarsilError, ServerErrorCodes, ErrorCodes } from './chunk-I64LXKO3.mjs';
 import { mkdtemp, open, rm } from 'fs/promises';
 import { tmpdir } from 'os';
@@ -423,6 +423,43 @@ function serializeBatchResult(result) {
   };
 }
 
+// src/server/regex-policy.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function regexFieldIn(expression, depth) {
+  if (!isRecord(expression) || depth > MAX_FILTER_DEPTH) return null;
+  if (isRecord(expression.fields)) {
+    for (const [fieldPath, filter] of Object.entries(expression.fields)) {
+      if (isRecord(filter) && Object.hasOwn(filter, "regex")) return fieldPath;
+    }
+  }
+  for (const nested of [expression.and, expression.or]) {
+    if (!Array.isArray(nested)) continue;
+    for (const child of nested) {
+      const found = regexFieldIn(child, depth + 1);
+      if (found !== null) return found;
+    }
+  }
+  return regexFieldIn(expression.not, depth + 1);
+}
+function refusedRegex(filters, allowRegex) {
+  if (allowRegex) return null;
+  const fieldPath = regexFieldIn(filters, 0);
+  if (fieldPath === null) return null;
+  return new NarsilError(
+    ErrorCodes.SEARCH_INVALID_FILTER,
+    `This server refuses every "regex" test, because its operator set the allowRegex server option to false. Test field "${fieldPath}" with "contains" or "wildcard"`,
+    { fieldPath, operator: "regex", option: "allowRegex" }
+  );
+}
+function refuseRegex(ctx, filters, allowRegex) {
+  const refused = refusedRegex(filters, allowRegex);
+  if (refused === null) return false;
+  respondError(ctx, refused);
+  return true;
+}
+
 // src/server/validation.ts
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -616,7 +653,7 @@ function parseTaskListQuery(params, maxPageSize) {
 
 // src/server/handlers/document-reads.ts
 function createDocumentReadHandlers(deps) {
-  const { engine, limits } = deps;
+  const { engine, limits, allowRegex } = deps;
   async function get(ctx) {
     try {
       const document = await engine.get(ctx.params[0], ctx.params[1]);
@@ -668,6 +705,7 @@ function createDocumentReadHandlers(deps) {
       rejectInvalid(ctx, failure);
       return;
     }
+    if (refuseRegex(ctx, params.filters, allowRegex)) return;
     try {
       respondJson(ctx, await engine.listDocuments(ctx.params[0], params));
     } catch (err) {
@@ -1155,4 +1193,4 @@ function childAppOf(app) {
   return candidate;
 }
 
-export { ASYNC_IMPORT_CAPABILITY, DEFAULT_IMPORT_BATCH_SIZE, DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_MAX_CONCURRENT_TASKS, DEFAULT_MAX_FETCH_DOCUMENTS, DEFAULT_MAX_IMPORT_BYTES, DEFAULT_MAX_IMPORT_ERRORS, DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_RESTORE_BYTES, DEFAULT_MAX_RESULT_WINDOW, DEFAULT_MAX_RETAINED_TASKS, DEFAULT_MAX_TASK_PAGE_SIZE, DEFAULT_TASK_PAGE_SIZE, DOCUMENT_EXPORT_CAPABILITY, DOCUMENT_EXPORT_CONTENT_TYPE, IMPORT_FLUSHES_IN_FLIGHT, INDEX_LIFECYCLE_CAPABILITY, INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT, MAIN_THREAD_GATE_SLOT, MAX_INDEX_TOUCH_INTERVAL_MS, MIN_COUNTED_SERVER_LIMIT, MIN_UNBOUNDED_SERVER_LIMIT, REBUILD_ANALYSIS_CAPABILITY, RELAY_STREAM_CHUNKS_IN_FLIGHT, RUNNING_TASK_TTL_MS, SERVER_CAPABILITIES, SNAPSHOT_ARCHIVE_CONTENT_TYPE, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, TASK_PROGRESS_WRITE_INTERVAL_MS, TERMINAL_TASK_TTL_MS, acceptorOf, authorizerFor, badRequest, childAppOf, clearGateSlot, corsHeaderReader, createDocumentReadHandlers, createRouteRunner, createSharedGateBuffer, createSharedRequestGate, createVersionHandler, gateSlotOfWorker, httpStatusForNarsilError, loadUWebSockets, parseJson, parseJsonOptional, parseTaskListQuery, registerServerRoutes, rejectInvalid, resolveCors, respondError, respondJson, sendError, sendRelayed, sendStream, serializeBatchResult, serializeNarsilError, serverRoutes, statusLine, toHttpError, validateBatch, validateCreateIndex, validateDocumentBody, validateQuery, validateRebalance, validateSuggest, versionReport };
+export { ASYNC_IMPORT_CAPABILITY, DEFAULT_IMPORT_BATCH_SIZE, DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_MAX_CONCURRENT_TASKS, DEFAULT_MAX_FETCH_DOCUMENTS, DEFAULT_MAX_IMPORT_BYTES, DEFAULT_MAX_IMPORT_ERRORS, DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_RESTORE_BYTES, DEFAULT_MAX_RESULT_WINDOW, DEFAULT_MAX_RETAINED_TASKS, DEFAULT_MAX_TASK_PAGE_SIZE, DEFAULT_TASK_PAGE_SIZE, DOCUMENT_EXPORT_CAPABILITY, DOCUMENT_EXPORT_CONTENT_TYPE, IMPORT_FLUSHES_IN_FLIGHT, INDEX_LIFECYCLE_CAPABILITY, INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT, MAIN_THREAD_GATE_SLOT, MAX_INDEX_TOUCH_INTERVAL_MS, MIN_COUNTED_SERVER_LIMIT, MIN_UNBOUNDED_SERVER_LIMIT, REBUILD_ANALYSIS_CAPABILITY, RELAY_STREAM_CHUNKS_IN_FLIGHT, RUNNING_TASK_TTL_MS, SERVER_CAPABILITIES, SNAPSHOT_ARCHIVE_CONTENT_TYPE, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, TASK_PROGRESS_WRITE_INTERVAL_MS, TERMINAL_TASK_TTL_MS, acceptorOf, authorizerFor, badRequest, childAppOf, clearGateSlot, corsHeaderReader, createDocumentReadHandlers, createRouteRunner, createSharedGateBuffer, createSharedRequestGate, createVersionHandler, gateSlotOfWorker, httpStatusForNarsilError, loadUWebSockets, parseJson, parseJsonOptional, parseTaskListQuery, refuseRegex, registerServerRoutes, rejectInvalid, resolveCors, respondError, respondJson, sendError, sendRelayed, sendStream, serializeBatchResult, serializeNarsilError, serverRoutes, statusLine, toHttpError, validateBatch, validateCreateIndex, validateDocumentBody, validateQuery, validateRebalance, validateSuggest, versionReport };

package/dist/{chunk-LJYTW7GT.mjs → chunk-IBR6634K.mjs}

@@ -290,4 +290,4 @@ function compareSortValues(aValues, bValues, directions) {
   return 0;
 }
 
-export { SORT_MODES, SORT_VALUE_MAX_CODE_POINTS, appendFoldedCodePoint, codePointCount, compareCodePoints, compareComparableKeys, compareComparableValues, compareSortValues, defaultSortMode, exceedsCodePoints, foldedCodePointCount, holdsUnpairedSurrogate, isSortMode, readSortField, sortModeOf, toComparableSortValue, toReducedSortValue, truncateSortString };
+export { SORT_MODES, SORT_VALUE_MAX_CODE_POINTS, appendFoldedCodePoint, codePointCount, compareCodePoints, compareComparableKeys, compareComparableValues, compareSortValues, defaultSortMode, exceedsCodePoints, foldedCodePointCount, holdsUnpairedSurrogate, isSortMode, readSortField, singleFoldTable, sortModeOf, toComparableSortValue, toReducedSortValue, truncateSortString };

package/dist/chunk-KEHK2O6P.mjs

@@ -0,0 +1,13 @@
+// src/vector/hnsw/constants.ts
+var MAX_LAYER_CAP = 32;
+var MAX_M = 512;
+var MIN_M = 2;
+var EARLIER_RELEASE_MIN_M = 1;
+var INITIAL_UPPER_SLOTS = 64;
+var INITIAL_LIST_CAPACITY = 64;
+var PLACEMENT_ROOM_REQUESTS = 8;
+var COMPACTION_TOMBSTONE_RATIO = 0.1;
+var COMPACTION_ABSOLUTE_THRESHOLD = 1e3;
+var DEFAULT_EF_SEARCH = 50;
+
+export { COMPACTION_ABSOLUTE_THRESHOLD, COMPACTION_TOMBSTONE_RATIO, DEFAULT_EF_SEARCH, EARLIER_RELEASE_MIN_M, INITIAL_LIST_CAPACITY, INITIAL_UPPER_SLOTS, MAX_LAYER_CAP, MAX_M, MIN_M, PLACEMENT_ROOM_REQUESTS };

package/dist/{chunk-CVFAFZSN.mjs → chunk-LOARLB4F.mjs}

@@ -1,14 +1,17 @@
+import { validateWorkerConfig, validateIndexName, validatePatternValueLimit, requireSurfaceFormsForPartialFields, validateBM25Params, validatePartitionConfig, executeQuery, queryBindingOf, executePreflight, executeSuggest, executeListDocuments, validateDocId } from './chunk-WL2GDSCV.mjs';
 import { ReplicationMessageTypes } from './chunk-GCM3JFVA.mjs';
-import { WIRE_BATCH_BUDGET, resolveVectorText, bindEngineCore, restoredConfigFields, restoredEmbedding, collectRequiredFieldFailures, embedChunkDocuments, providedDocId, requireDocumentObject, admitInsert, asBatchInsertError, requireMatchingDocId, embedDocumentFields, assertDocumentCarriesMappedVectors, admitBufferedUpsert, createPendingAdmissions, recordPendingAdmission } from './chunk-AFKH4ZK3.mjs';
-import { NATIVE_CRC32_MIN_BYTES, generateId, decodeEveryStoredDocument, createSharedFrozenSegment, splitWorkerBudget, resolveWorkerCount, createDirectExecutor, createPartitionRouter, requirePatternSearchFor, MAX_FILE_BYTES, resolveWorkerEntry, missingWorkerEntry, readHeapStatistics, nodeThreadId, CHECKSUM_YIELD_CHUNK_BYTES, createPartitionManager, buildSegmentPayload, resolvePartitionInsertOptions, createFrozenSegment, resolveRequestThreadCount, vectorsPerFile, vectorsToBytes, VECTOR_FILE_PAYLOAD_VERSION, deadBitsWhere, NO_LIVE_VECTOR_AT_POSITION, createPartitionIndex, selectionKeeps, decodeMapWithoutFields, isCompositePartition, segmentArraysOf, mergeSegmentContents, survivorDocumentsOf, partitionStateOf, VECTOR_FILE_MAX_VECTORS, deadBytesFor, resolveIndexAnalysis, mergeFrozenSegments, workerResourceLimits, decodeVectorIndexParts, bytesToVectors, freezeSegmentShared, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, SHUTDOWN_TIMEOUT_MS, decodeVectorFilePayload, decodeVectorGraphPartPayload, assembleGraphParts, countDead, encodeSegmentState, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, VALID_HNSW_METRICS, spawnNodeWorker, decodeVectorGraphPayload, graphPartsOfEarlierPayload, decodeStoredDocument, isDead } from './chunk-THMSFOJO.mjs';
+import { WIRE_BATCH_BUDGET, resolveVectorText, bindEngineCore, restoredConfigFields, restoredEmbedding, collectRequiredFieldFailures, embedChunkDocuments, providedDocId, requireDocumentObject, admitInsert, asBatchInsertError, requireMatchingDocId, embedDocumentFields, assertDocumentCarriesMappedVectors, admitBufferedUpsert, createPendingAdmissions, recordPendingAdmission } from './chunk-BT62MUM5.mjs';
+import { NATIVE_CRC32_MIN_BYTES, generateId, decodeEveryStoredDocument, createSharedFrozenSegment, shareSegmentArrays, splitWorkerBudget, resolveWorkerCount, createDirectExecutor, createPartitionRouter, requirePartialWordSearchFor, MAX_FILE_BYTES, resolveWorkerEntry, missingWorkerEntry, readHeapStatistics, nodeThreadId, CHECKSUM_YIELD_CHUNK_BYTES, createPartitionManager, buildSegmentPayload, resolvePartitionInsertOptions, createFrozenSegment, resolveRequestThreadCount, vectorsPerFile, vectorsToBytes, VECTOR_FILE_PAYLOAD_VERSION, deadBitsWhere, NO_LIVE_VECTOR_AT_POSITION, createPartitionIndex, selectionKeeps, decodeMapWithoutFields, isCompositePartition, segmentArraysOf, mergeSegmentContents, survivorDocumentsOf, partitionStateOf, VECTOR_FILE_MAX_VECTORS, deadBytesFor, resolveIndexAnalysis, mergeFrozenSegments, workerResourceLimits, decodeVectorIndexParts, bytesToVectors, freezeSegmentShared, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, SHUTDOWN_TIMEOUT_MS, decodeVectorFilePayload, decodeVectorGraphPartPayload, assembleGraphParts, countDead, encodeSegmentState, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, VALID_HNSW_METRICS, spawnNodeWorker, decodeVectorGraphPayload, graphPartsOfEarlierPayload, decodeStoredDocument, isDead } from './chunk-YOVS4EV5.mjs';
+import { requirePatternSearchFor, collectQueryTermStats, mergePartitionStats, oversampledFacetConfig, fnv1a, availablePatternSearch, kWayMerge, mergeFacets, PATTERN_HOST, setNestedValue } from './chunk-NAMGDK45.mjs';
 import { detectRuntime, getLanguage } from './chunk-4MQ5F4IL.mjs';
-import { validateWorkerConfig, validateIndexName, validatePatternValueLimit, validateBM25Params, validatePartitionConfig, executeQuery, queryBindingOf, executePreflight, executeSuggest, executeListDocuments, validateDocId } from './chunk-ZULSEZCE.mjs';
-import { getNestedValue, collectQueryTermStats, mergePartitionStats, oversampledFacetConfig, fnv1a, kWayMerge, mergeFacets, parseVectorDimension, setNestedValue } from './chunk-3YKWSO54.mjs';
-import { extractVectorFieldsFromSchema, messagePackUpperBoundBytes, MAX_INDEX_CONFIGURATION_BYTES, validateSchema, requireCreatableSchema, validateVectorPromotion, validateVectorStorage, raiseEarlierReleaseGraphSetting, flattenSchema, isSingleStringFieldType, requireValidFieldTypes, encodeDocument, STATISTICS_BROADCAST_INTERVAL_MS, MAX_SWEEP_INTERVAL_MS, MIN_SWEEP_INTERVAL_MS, HEAP_PRESSURE_WARNING_FRACTION, MAX_EXPORT_LINE_BYTES, IMPORT_BATCH_DOCUMENTS, VECTOR_PATTERN, schemaFieldsOf, FOREIGN_STATS_TTL_MS, MAX_IMPORT_REFUSALS_REPORTED, BATCH_CHUNK_SIZE, MIN_DOCUMENTS_FOR_SEGMENTS, MAX_DOCUMENT_NESTING_DEPTH, isQuantizationMode, isStorageMode, HEAP_PRESSURE_REARM_FRACTION, EXPORT_CHUNK_BYTES, validateRequiredFields, requireDocumentWithinSizeLimit, validateDocument, validateDocumentStrict } from './chunk-AK3BLGCI.mjs';
-import { releaseLocksHeldBy } from './chunk-WVDFG45M.mjs';
-import { requireSearchBackendSettings, MIN_M } from './chunk-PU43WDY4.mjs';
-import { DEFAULT_PATTERN_WORK_CAP, MATCHER_STATE_BUDGET_BYTES, MATCHER_SIMULATION_BYTES_PER_POSITION, MATCHER_STATE_OVERHEAD_BYTES, PATTERN_TEST_OPERATORS, MATCHER_CODE_POINT_BYTES } from './chunk-ZKRV5M2P.mjs';
-import { compareCodePoints, foldedCodePointCount, codePointCount } from './chunk-LJYTW7GT.mjs';
+import { MAX_INDEX_CONFIGURATION_BYTES, STATISTICS_BROADCAST_INTERVAL_MS, MAX_SWEEP_INTERVAL_MS, MIN_SWEEP_INTERVAL_MS, HEAP_PRESSURE_WARNING_FRACTION, MAX_EXPORT_LINE_BYTES, IMPORT_BATCH_DOCUMENTS, FOREIGN_STATS_TTL_MS, MAX_IMPORT_REFUSALS_REPORTED, BATCH_CHUNK_SIZE, MIN_DOCUMENTS_FOR_SEGMENTS, HEAP_PRESSURE_REARM_FRACTION, EXPORT_CHUNK_BYTES } from './chunk-V3B24XR7.mjs';
+import { releaseLocksHeldBy } from './chunk-AMGDG4ZJ.mjs';
+import { requireSearchBackendSettings } from './chunk-2E35UM3G.mjs';
+import { DEFAULT_PATTERN_WORK_CAP, MATCHER_STATE_BUDGET_BYTES, PATTERN_TEST_OPERATORS, PATTERN_EXPRESSION_OPERATORS, MATCHER_CODE_POINT_BYTES, MATCHER_SIMULATION_BYTES_PER_POSITION, MATCHER_STATE_OVERHEAD_BYTES } from './chunk-7ODNRREZ.mjs';
+import { getNestedValue, parseVectorDimension } from './chunk-UOJIV2NG.mjs';
+import { extractVectorFieldsFromSchema, messagePackUpperBoundBytes, validateSchema, requireCreatableSchema, validateVectorPromotion, validateVectorStorage, raiseEarlierReleaseGraphSetting, flattenSchema, isSingleStringFieldType, requireValidFieldTypes, encodeDocument, VECTOR_PATTERN, schemaFieldsOf, MAX_DOCUMENT_NESTING_DEPTH, isQuantizationMode, isStorageMode, validateRequiredFields, requireDocumentWithinSizeLimit, validateDocument, validateDocumentStrict } from './chunk-356UOTK2.mjs';
+import { MIN_M } from './chunk-KEHK2O6P.mjs';
+import { compareCodePoints, foldedCodePointCount, codePointCount } from './chunk-IBR6634K.mjs';
 import { createRequestId, isValidWorkerResponse, threadSlotOfWorker } from './chunk-POWOTUKJ.mjs';
 import { ErrorCodes, NarsilError } from './chunk-I64LXKO3.mjs';
 import { encode, decode } from '@msgpack/msgpack';
@@ -3502,7 +3505,7 @@ function selectionOfMask(segment, keep) {
 }
 function frozenLiveTail(live, shared) {
   if (live.count() === 0) return null;
-  const payload = live.encodeSegment();
+  const payload = { ...live.encodeSegment(), partialSpellings: null };
   const documents = survivorDocumentsOf(partitionStateOf(live), payload);
   if (shared) {
     const snapshot = freezeSegmentShared(payload, documents);
@@ -5018,6 +5021,7 @@ function emptyPayload() {
     totalFieldLengths: {},
     docFrequencies: {},
     surfaceForms: null,
+    partialSpellings: null,
     numeric: [],
     boolean: [],
     enums: [],
@@ -5123,7 +5127,7 @@ function chooseWindow(segments, wantedLength) {
   return null;
 }
 function frozenOf(contents) {
-  return createSharedFrozenSegment({ ...contents.arrays, segmentId: generateId() });
+  return createSharedFrozenSegment(shareSegmentArrays(contents.arrays, null));
 }
 function applyTimeOrder(frozen, contents) {
   for (let newer = 1; newer < frozen.length; newer++) {
@@ -5391,7 +5395,7 @@ async function loadPartitionSegments(store, partition, manager, options) {
     const contents = await readSegmentFile(store, ref);
     requireAgreedSchema(options.schema, contents.schema, ref.key);
     if (options.decodesEveryDocument) decodeEveryStoredDocument(contents.arrays.documentTable);
-    const segment = createSharedFrozenSegment({ ...contents.arrays, segmentId: generateId() });
+    const segment = createSharedFrozenSegment(shareSegmentArrays(contents.arrays, manager.partialWordAnalysis));
     removeWhatTheSegmentReplaces(manager, segment, contents);
     if (contents.arrays.documentCount > 0) manager.attachFrozenSegment(partition.partitionId, segment);
     await yieldToEventLoop4();
@@ -7881,6 +7885,7 @@ async function createIndexFromMetadata(deps, metadata, loadData) {
   try {
     indexConfig.schema = validateSchema(indexConfig.schema);
     validatePatternValueLimit(indexConfig.patternValueLimit);
+    requireSurfaceFormsForPartialFields(indexConfig.schema, indexConfig.surfaceForms);
   } catch (err) {
     throw recoveryFailure(metadata, err);
   }
@@ -8594,7 +8599,7 @@ function checkHeapAfterRecovery(core) {
 }
 
 // src/core/partition/frozen/share.ts
-function shareFrozenSegment(segment) {
+function shareFrozenSegment(segment, analysis) {
   if (segment.sharedSnapshot !== null) {
     return { snapshot: segment.sharedSnapshot, tombstonedDocIds: segment.tombstonedDocIds() };
   }
@@ -8608,7 +8613,7 @@ function shareFrozenSegment(segment) {
     }
     return stored.fields;
   });
-  const snapshot = freezeSegmentShared(payload, documents, segment.segmentId);
+  const snapshot = freezeSegmentShared(payload, documents, segment.segmentId, analysis);
   return snapshot === null ? null : { snapshot, tombstonedDocIds: [] };
 }
 
@@ -8619,7 +8624,7 @@ function captureComposite(manager, partitionId) {
   const segmentIds = partition.frozenSegmentSizes().map((size) => size.segmentId);
   const frozen = [];
   for (const segment of partition.frozenSegmentsById(segmentIds)) {
-    const shared = shareFrozenSegment(segment);
+    const shared = shareFrozenSegment(segment, manager.partialWordAnalysis);
     if (shared === null) return null;
     frozen.push(shared);
   }
@@ -9004,7 +9009,7 @@ function liveTailCount(manager, partitionId) {
 }
 function freezeIntoSharedSegment(manager, partitionId) {
   return manager.freezeLiveTail(partitionId, (payload, documents) => {
-    const snapshot = freezeSegmentShared(payload, documents);
+    const snapshot = freezeSegmentShared(payload, documents, void 0, manager.partialWordAnalysis);
     return snapshot === null ? null : createSharedFrozenSegment(snapshot);
   });
 }
@@ -9127,7 +9132,7 @@ async function compactPartitionSegments2(state, indexName, manager, partitionId,
   const mainCanMerge = composite !== null && mainHoldsAll(composite, segmentIds);
   let snapshot = await compactOnWorker(state, indexName, partitionId, segmentIds);
   if (snapshot === null && mainCanMerge && composite !== null) {
-    snapshot = mergeFrozenSegments(composite.frozenSegmentsById(segmentIds));
+    snapshot = mergeFrozenSegments(composite.frozenSegmentsById(segmentIds), manager.partialWordAnalysis);
   }
   if (snapshot === null) {
     if (!mainCanMerge) forgetLedgerSegments(state, indexName, partitionId, segmentIds);
@@ -10223,57 +10228,61 @@ 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;
+  return 2 * positionWords(positions) * Uint32Array.BYTES_PER_ELEMENT + positions * MATCHER_CODE_POINT_BYTES + 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)));
+function widestPatternSplit(footprintBytes) {
+  return Math.max(1, Math.floor(MATCHER_STATE_BUDGET_BYTES / Math.max(1, footprintBytes)));
 }
 
 // src/core/pattern-index/query-positions.ts
 function isRecord4(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 literalFootprint(text, caseFold) {
+  if (typeof text !== "string") return null;
+  return smallestMatcherBytes(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) {
+function largestTestOf(filter, module) {
   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));
+    for (const text of texts) largest = larger(largest, literalFootprint(text, caseFold));
+  }
+  for (const operator of PATTERN_EXPRESSION_OPERATORS) {
+    const pattern = filter[operator];
+    if (typeof pattern !== "string") continue;
+    largest = larger(largest, module.expressionFootprint(operator, pattern, caseFold, PATTERN_HOST));
   }
   return largest;
 }
-function largestIn(expression, patternFields) {
+function largestIn(expression, patternFields, module) {
   let largest = null;
   if (isRecord4(expression.fields)) {
     for (const [fieldPath, filter] of Object.entries(expression.fields)) {
-      if (patternFields.has(fieldPath) && isRecord4(filter)) largest = larger(largest, largestTestOf(filter));
+      if (patternFields.has(fieldPath) && isRecord4(filter)) largest = larger(largest, largestTestOf(filter, module));
     }
   }
   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));
+  for (const child of nested) largest = larger(largest, largestIn(child, patternFields, module));
   return largest;
 }
-function largestPatternTest(expression, schema) {
+function largestPatternFootprint(expression, schema) {
   if (expression === void 0) return null;
+  const module = availablePatternSearch();
+  if (module === null) 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);
+  return patternFields.size === 0 ? null : largestIn(expression, patternFields, module);
 }
 
 // src/engine/orchestration/search.ts
@@ -10340,7 +10349,7 @@ function isWorkCapError(err) {
 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);
+  const largest = largestPatternFootprint(params.filters, schema);
   if (largest === null) return Number.POSITIVE_INFINITY;
   if (typeof SharedArrayBuffer !== "function") return 1;
   return widestPatternSplit(largest);
@@ -11117,7 +11126,9 @@ async function createEngineIndex(core, config, name, requestedConfig, creation =
   if (appliesCreationLimits) requireCreatableSchema(schema);
   const indexConfig = schema === requestedConfig.schema ? requestedConfig : { ...requestedConfig, schema };
   requirePatternSearchFor(schema);
+  requirePartialWordSearchFor(schema);
   validatePatternValueLimit(indexConfig.patternValueLimit);
+  requireSurfaceFormsForPartialFields(schema, indexConfig.surfaceForms);
   validateVectorPromotion(indexConfig.vectorPromotion);
   validateVectorStorage(indexConfig.vectorPromotion, core.filesystemDurability);
   validateBM25Params(indexConfig.bm25);
@@ -13918,6 +13929,7 @@ function prepareRestoredIndex(configuration, deps, reject) {
   const language = getLanguage(languageName);
   const schema = validateSchema(configuration.schema);
   validatePatternValueLimit(configFields.patternValueLimit);
+  requireSurfaceFormsForPartialFields(schema, configFields.surfaceForms);
   validateVectorPromotion(configFields.vectorPromotion);
   validateVectorStorage(configFields.vectorPromotion, deps.filesystemDurability);
   if (configFields.required !== void 0 && configFields.required.length > 0) {