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

package/dist/{capabilities-B1wz2Zl0.d.ts → capabilities-Dt-7B4Wz.d.ts}

@@ -1,6 +1,6 @@
 import { E as EmbeddingAdapter } from './adapters-79OIa4xm.js';
-import { C as ClusterNamespace } from './config-CSvCVtB7.js';
-import { h as TaskStore } from './tasks-BEiNxDRs.js';
+import { C as ClusterNamespace } from './config-rBpbgTw8.js';
+import { h as TaskStore } from './tasks-BZt_zes6.js';
 
 /**
  * Context handed to {@link OnRequestHook} for every inbound request, captured

package/dist/{chunk-DD5X23E6.mjs → chunk-2STVUTNA.mjs}

@@ -1,4 +1,4 @@
-import { MAX_SORT_FIELDS } from './chunk-6TGZG2TV.mjs';
+import { MAX_SORT_FIELDS } from './chunk-653BNMAF.mjs';
 import { nativeSearchCoreIsEnabled, loadNativeCore } from './chunk-YNVIUGF5.mjs';
 import { NarsilError, ServerErrorCodes, ErrorCodes } from './chunk-USKFU7J5.mjs';
 

package/dist/chunk-3JGWULDF.mjs

@@ -0,0 +1,256 @@
+import { readSharedConfigFields, restoredEmbedding, restoredPartitionConfig, MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR } from './chunk-FVLQ63B7.mjs';
+import { getLanguage } from './chunk-HWQLTLNG.mjs';
+import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN } from './chunk-GIVAGD3Q.mjs';
+import { compareCodePoints } from './chunk-OI42GWLR.mjs';
+import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
+import { encode, decode } from '@msgpack/msgpack';
+
+// src/distribution/cluster/index-settings.ts
+function partitionLimitsOf(partitions) {
+  if (partitions === void 0) {
+    return void 0;
+  }
+  const { maxDocsPerPartition, watermark } = partitions;
+  if (maxDocsPerPartition === void 0 && watermark === void 0) {
+    return void 0;
+  }
+  return {
+    ...maxDocsPerPartition !== void 0 ? { maxDocsPerPartition } : {},
+    ...watermark !== void 0 ? { watermark } : {}
+  };
+}
+function codeInSettings(option, registration) {
+  return new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `A node cannot serialise code into the cluster's index metadata, so register the index ${option} with ${registration} and pass its name`,
+    { option }
+  );
+}
+function settingsFieldsOf(source) {
+  const { tokenizer, stopWords, bm25, embedding } = source;
+  const partitionConfig = partitionLimitsOf(source.partitions);
+  if (tokenizer !== void 0 && typeof tokenizer !== "string") {
+    throw codeInSettings("tokenizer", "registerTokenizer");
+  }
+  if (typeof stopWords === "function") {
+    throw codeInSettings("stop words", "registerStopWords");
+  }
+  if (embedding?.adapter !== void 0 && typeof embedding.adapter !== "string") {
+    throw codeInSettings("embedding adapter", "registerEmbeddingAdapter");
+  }
+  return {
+    ...tokenizer !== void 0 ? { tokenizer } : {},
+    ...typeof stopWords === "string" ? { stopWords } : {},
+    ...stopWords instanceof Set ? { stopWordList: [...stopWords].sort(compareCodePoints) } : {},
+    ...bm25 !== void 0 ? {
+      bm25: {
+        ...bm25.k1 !== void 0 ? { k1: bm25.k1 } : {},
+        ...bm25.b !== void 0 ? { b: bm25.b } : {}
+      }
+    } : {},
+    ...source.surfaceForms !== void 0 ? { surfaceForms: source.surfaceForms } : {},
+    ...source.defaultScoring !== void 0 ? { defaultScoring: source.defaultScoring } : {},
+    ...source.trackPositions !== void 0 ? { trackPositions: source.trackPositions } : {},
+    ...source.strict !== void 0 ? { strict: source.strict } : {},
+    ...source.required !== void 0 ? { required: source.required } : {},
+    ...source.vectorPromotion !== void 0 ? { vectorPromotion: source.vectorPromotion } : {},
+    ...source.patternValueLimit !== void 0 ? { patternValueLimit: source.patternValueLimit } : {},
+    ...partitionConfig !== void 0 ? { partitionConfig } : {},
+    ...embedding !== void 0 ? {
+      embedding: {
+        fields: embedding.fields,
+        ...typeof embedding.adapter === "string" ? { adapter: embedding.adapter } : {}
+      }
+    } : {}
+  };
+}
+function indexSettingsOf(config) {
+  return {
+    language: getLanguage(config.language ?? "english").name,
+    ...settingsFieldsOf(config)
+  };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function settingsRejection(indexName) {
+  return (message) => {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      `Index metadata for '${indexName}' has invalid settings: ${message}`,
+      { indexName }
+    );
+  };
+}
+function decodeIndexSettings(raw, indexName) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  const reject = settingsRejection(indexName);
+  if (!isRecord(raw)) {
+    return reject("settings must be an object");
+  }
+  if (typeof raw.language !== "string" || raw.language.length === 0) {
+    return reject("language must be a name");
+  }
+  const embedding = restoredEmbedding(raw.embedding, reject);
+  const partitions = restoredPartitionConfig(raw.partitionConfig, reject);
+  return {
+    language: raw.language,
+    ...settingsFieldsOf({
+      ...readSharedConfigFields(raw, reject),
+      ...partitions !== void 0 ? { partitions } : {},
+      ...embedding !== void 0 ? { embedding } : {}
+    })
+  };
+}
+function withPartitionCount(config, partitionCount) {
+  return { ...config, partitions: { ...config.partitions, maxPartitions: partitionCount } };
+}
+function indexConfigFromSettings(schema, settings, indexName) {
+  if (settings === void 0) {
+    return { schema };
+  }
+  const { language, embedding, partitionConfig, ...fields } = settings;
+  return {
+    schema,
+    language,
+    ...readSharedConfigFields(fields, settingsRejection(indexName)),
+    ...partitionConfig !== void 0 ? { partitions: { ...partitionConfig } } : {},
+    ...embedding !== void 0 ? { embedding } : {}
+  };
+}
+var INDEX_CONFIG_PREFIX = "_narsil/index/";
+var INDEX_CONFIG_SUFFIX = "/config";
+function truncateForDisplay(value) {
+  const str = String(value);
+  if (str.length > 100) {
+    return `${str.slice(0, 100)}...`;
+  }
+  return str;
+}
+function validateIndexName(indexName) {
+  if (indexName.length === 0 || indexName.length > MAX_INDEX_NAME_LENGTH) {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      `Index name must be between 1 and ${MAX_INDEX_NAME_LENGTH} characters`,
+      { indexName: truncateForDisplay(indexName) }
+    );
+  }
+  if (indexName.includes("\0") || indexName.includes("/") || indexName.includes("\\") || indexName.includes("..")) {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      "Index name contains forbidden characters (/, \\, .., or null bytes)",
+      { indexName: truncateForDisplay(indexName) }
+    );
+  }
+  if (!INDEX_NAME_PATTERN.test(indexName)) {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      "Index name must start with an alphanumeric character and contain only alphanumeric characters, hyphens, underscores, or dots",
+      { indexName: truncateForDisplay(indexName) }
+    );
+  }
+}
+function isValidInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+}
+function indexConfigKey(indexName) {
+  return `${INDEX_CONFIG_PREFIX}${indexName}${INDEX_CONFIG_SUFFIX}`;
+}
+function validateDecodedMetadata(decoded, indexName) {
+  if (!isRecord(decoded)) {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      `Index metadata for '${indexName}' is not an object`,
+      { indexName }
+    );
+  }
+  if (typeof decoded.indexUuid !== "string" || decoded.indexUuid.length === 0 || decoded.indexUuid.length > 128) {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      `Index metadata for '${indexName}' has invalid indexUuid`,
+      { indexName, received: truncateForDisplay(decoded.indexUuid) }
+    );
+  }
+  if (typeof decoded.indexName !== "string") {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      `Index metadata for '${indexName}' has invalid indexName`,
+      { indexName, received: truncateForDisplay(decoded.indexName) }
+    );
+  }
+  if (!isValidInteger(decoded.partitionCount) || decoded.partitionCount <= 0 || decoded.partitionCount > MAX_PARTITION_COUNT) {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      `Index metadata for '${indexName}' has invalid partitionCount (must be an integer between 1 and ${MAX_PARTITION_COUNT})`,
+      { indexName, partitionCount: truncateForDisplay(decoded.partitionCount) }
+    );
+  }
+  if (!isValidInteger(decoded.replicationFactor) || decoded.replicationFactor < 0 || decoded.replicationFactor > MAX_REPLICATION_FACTOR) {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      `Index metadata for '${indexName}' has invalid replicationFactor (must be an integer between 0 and ${MAX_REPLICATION_FACTOR})`,
+      { indexName, replicationFactor: truncateForDisplay(decoded.replicationFactor) }
+    );
+  }
+  if (!isRecord(decoded.constraints)) {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      `Index metadata for '${indexName}' has invalid constraints`,
+      { indexName }
+    );
+  }
+  const constraints = decoded.constraints;
+  if (constraints.maxShardsPerNode !== void 0 && constraints.maxShardsPerNode !== null && typeof constraints.maxShardsPerNode !== "number") {
+    throw new NarsilError(
+      ErrorCodes.CONTROLLER_METADATA_INVALID,
+      `Index metadata for '${indexName}' has invalid maxShardsPerNode (must be a number or null)`,
+      { indexName, maxShardsPerNode: truncateForDisplay(constraints.maxShardsPerNode) }
+    );
+  }
+  return {
+    indexUuid: decoded.indexUuid,
+    indexName: decoded.indexName,
+    partitionCount: decoded.partitionCount,
+    replicationFactor: decoded.replicationFactor,
+    constraints: {
+      zoneAwareness: constraints.zoneAwareness === true,
+      zoneAttribute: typeof constraints.zoneAttribute === "string" ? constraints.zoneAttribute : "zone",
+      maxShardsPerNode: typeof constraints.maxShardsPerNode === "number" ? constraints.maxShardsPerNode : null
+    }
+  };
+}
+async function putIndexMetadata(coordinator, metadata) {
+  validateIndexName(metadata.indexName);
+  const key = indexConfigKey(metadata.indexName);
+  const encoded = encode(metadata, { ignoreUndefined: true });
+  const bytes = new Uint8Array(encoded);
+  if (await coordinator.compareAndSet(key, null, bytes)) {
+    return true;
+  }
+  const current = await coordinator.get(key);
+  if (current === null || current.byteLength > 0) {
+    return false;
+  }
+  return coordinator.compareAndSet(key, current, bytes);
+}
+async function readStoredMetadata(coordinator, indexName) {
+  validateIndexName(indexName);
+  const raw = await coordinator.get(indexConfigKey(indexName));
+  if (raw === null || raw.byteLength === 0) {
+    return null;
+  }
+  const decoded = decode(raw);
+  const record = validateDecodedMetadata(decoded, indexName);
+  return { record, rawSettings: isRecord(decoded) ? decoded.settings : void 0 };
+}
+async function getIndexMetadata(coordinator, indexName) {
+  return (await readStoredMetadata(coordinator, indexName))?.record ?? null;
+}
+async function getClusterIndexConfig(coordinator, indexName, schema) {
+  const stored = await readStoredMetadata(coordinator, indexName);
+  return indexConfigFromSettings(schema, decodeIndexSettings(stored?.rawSettings, indexName), indexName);
+}
+
+export { getClusterIndexConfig, getIndexMetadata, indexConfigKey, indexSettingsOf, putIndexMetadata, validateIndexName, withPartitionCount };

package/dist/{chunk-6TGZG2TV.mjs → chunk-653BNMAF.mjs}

@@ -1,27 +1,15 @@
 import { MAX_M } from './chunk-YNVIUGF5.mjs';
+import { exceedsCodePoints } from './chunk-OI42GWLR.mjs';
 import { NarsilError, ErrorCodes } from './chunk-USKFU7J5.mjs';
 
 // 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 SORTABLE_TEXT_FIELD_TYPE = "string:sortable";
-var SCALAR_FIELD_TYPES = /* @__PURE__ */ new Set([
-  "string",
-  SORTABLE_TEXT_FIELD_TYPE,
-  "number",
-  "boolean",
-  "enum",
-  "geopoint",
-  "string[]",
-  "number[]",
-  "boolean[]",
-  "enum[]"
-]);
-function isTextFieldType(fieldType) {
-  return fieldType === "string" || fieldType === SORTABLE_TEXT_FIELD_TYPE;
-}
 var VECTOR_PATTERN = /^vector\[(\d+)]$/;
 function isGeopointOrVectorType(fieldType) {
   return fieldType === "geopoint" || fieldType !== void 0 && VECTOR_PATTERN.test(fieldType);
@@ -33,6 +21,114 @@ 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) {
@@ -42,6 +138,11 @@ function validateSchemaFields(schema, depth, 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)) {
@@ -65,7 +166,8 @@ function validateSchemaFields(schema, depth, prefix) {
       );
     }
     if (isPlainObject(type)) {
-      validateSchemaFields(type, depth + 1, path);
+      const nested = validateSchemaFields(type, depth + 1, path);
+      if (nested !== type) replace(field, nested);
       continue;
     }
     if (typeof type !== "string") {
@@ -78,24 +180,10 @@ function validateSchemaFields(schema, depth, prefix) {
         }
       );
     }
-    if (SCALAR_FIELD_TYPES.has(type)) continue;
-    const vectorMatch = VECTOR_PATTERN.exec(type);
-    if (vectorMatch) {
-      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 }
-        );
-      }
-      continue;
-    }
-    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, `Field "${path}" has an unsupported type: "${type}"`, {
-      field: path,
-      type
-    });
+    const parsed = parseFieldType(type, path);
+    if (parsed.type !== type) replace(field, parsed.type);
   }
+  return canonical ?? schema;
 }
 function validateSchema(schema) {
   if (!isPlainObject(schema)) {
@@ -106,7 +194,19 @@ function validateSchema(schema) {
   if (Object.keys(schema).length === 0) {
     throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must define at least one field");
   }
-  validateSchemaFields(schema, 1, "");
+  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)) {
@@ -127,14 +227,22 @@ function flattenSchema(schema) {
   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 flat = flattenSchema(schema);
   const result = /* @__PURE__ */ new Map();
-  for (const [fieldPath, fieldType] of Object.entries(flat)) {
-    const match = VECTOR_PATTERN.exec(fieldType);
-    if (match) {
-      result.set(fieldPath, Number.parseInt(match[1], 10));
-    }
+  for (const field of schemaFieldsOf(schema)) {
+    if (field.base === "vector") result.set(field.path, field.dimension);
   }
   return result;
 }
@@ -231,10 +339,19 @@ function validateTypedArray(path, value, elementType) {
     }
   }
 }
-function validateFieldValue(path, value, type) {
-  switch (type) {
+function validatePatternValue(path, value, patternValueLimit, index) {
+  if (!exceedsCodePoints(value, patternValueLimit)) return;
+  const subject = index === void 0 ? `The value of field "${path}"` : `Element ${index} of field "${path}"`;
+  throw new NarsilError(
+    ErrorCodes.DOC_VALIDATION_FAILED,
+    `${subject} is longer than ${patternValueLimit} code points, which is the pattern value limit of this index`,
+    { field: path, limit: patternValueLimit, ...index === void 0 ? {} : { index } }
+  );
+}
+function validateFieldValue(path, value, type, patternValueLimit) {
+  switch (type.base) {
     case "string":
-    case SORTABLE_TEXT_FIELD_TYPE:
+    case "verbatim":
       if (typeof value !== "string") {
         throw new NarsilError(
           ErrorCodes.DOC_VALIDATION_FAILED,
@@ -246,6 +363,7 @@ function validateFieldValue(path, value, type) {
           }
         );
       }
+      if (type.pattern) validatePatternValue(path, value, patternValueLimit);
       return;
     case "number":
       if (typeof value !== "number" || Number.isNaN(value)) {
@@ -286,7 +404,12 @@ function validateFieldValue(path, value, type) {
       validateGeopoint(path, value);
       return;
     case "string[]":
+    case "verbatim[]":
       validateTypedArray(path, value, "string");
+      if (type.pattern) {
+        const elements = value;
+        for (let i = 0; i < elements.length; i++) validatePatternValue(path, elements[i], patternValueLimit, i);
+      }
       return;
     case "number[]":
       validateTypedArray(path, value, "number");
@@ -297,12 +420,9 @@ function validateFieldValue(path, value, type) {
     case "enum[]":
       validateTypedArray(path, value, "string");
       return;
-    default: {
-      const vectorMatch = VECTOR_PATTERN.exec(type);
-      if (vectorMatch) {
-        validateVector(path, value, Number.parseInt(vectorMatch[1], 10));
-      }
-    }
+    case "vector":
+      validateVector(path, value, type.dimension);
+      return;
   }
 }
 
@@ -383,32 +503,44 @@ function vectorFieldPaths(schema) {
   vectorPathCache.set(schema, paths);
   return paths;
 }
-function validateDocumentFields(doc, schema, prefix) {
-  for (const [field, type] of Object.entries(schema)) {
+var parsedLevelCache = /* @__PURE__ */ new WeakMap();
+function parsedLevel(schema, prefix) {
+  let entries = parsedLevelCache.get(schema);
+  if (entries !== void 0) return entries;
+  entries = Object.entries(schema).map(([field, type]) => {
+    if (isPlainObject(type)) return { field, nested: type, type: null };
     const path = prefix ? `${prefix}.${field}` : field;
+    return { field, nested: null, type: parseFieldType(type, path) };
+  });
+  parsedLevelCache.set(schema, entries);
+  return entries;
+}
+function validateDocumentFields(doc, schema, prefix, patternValueLimit) {
+  for (const { field, nested, type } of parsedLevel(schema, prefix)) {
     const value = doc[field];
     if (value === void 0 || value === null) continue;
-    if (isPlainObject(type)) {
+    const path = prefix ? `${prefix}.${field}` : field;
+    if (nested !== null) {
       if (!isPlainObject(value)) {
         throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected an object`, {
           field: path,
           received: Array.isArray(value) ? "array" : typeof value
         });
       }
-      validateDocumentFields(value, type, path);
+      validateDocumentFields(value, nested, path, patternValueLimit);
       continue;
     }
-    validateFieldValue(path, value, type);
+    if (type !== null) validateFieldValue(path, value, type, patternValueLimit);
   }
 }
-function validateDocument(document, schema) {
+function validateDocument(document, schema, patternValueLimit = DEFAULT_PATTERN_VALUE_LIMIT) {
   if (!isPlainObject(document)) {
     throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, "Document must be a plain object", {
       received: typeof document
     });
   }
   assertStorableDocument(document, vectorFieldPaths(schema));
-  validateDocumentFields(document, schema, "");
+  validateDocumentFields(document, schema, "", patternValueLimit);
 }
 function collectExtraFields(doc, schema, prefix, extras) {
   for (const key of Object.keys(doc)) {
@@ -526,4 +658,4 @@ var DEFAULT_LINEAR_ALPHA = 0.5;
 var MIN_LINEAR_ALPHA = 0;
 var MAX_LINEAR_ALPHA = 1;
 
-export { DEFAULT_FUZZY_PREFIX_LENGTH, DEFAULT_LINEAR_ALPHA, DEFAULT_MAX_PER_GROUP, DEFAULT_PAGE_SIZE, DEFAULT_RANK_CONSTANT, MAX_CURSOR_ANCHOR_CODE_POINTS, MAX_CURSOR_LENGTH, MAX_LINEAR_ALPHA, MAX_NESTING_DEPTH, MAX_PREFIX_LENGTH, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_TOLERANCE, MIN_LINEAR_ALPHA, MIN_RANK_CONSTANT, PREFIX_MAX_EXPANSIONS, PROTOTYPE_POLLUTION_KEYS, RESULT_WINDOW, SORTABLE_TEXT_FIELD_TYPE, VECTOR_PATTERN, extractVectorFieldsFromSchema, flattenSchema, isGeopointOrVectorType, isQuantizationMode, isStorageMode, isTextFieldType, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion, validateVectorStorage };
+export { DEFAULT_FUZZY_PREFIX_LENGTH, DEFAULT_LINEAR_ALPHA, DEFAULT_MAX_PER_GROUP, DEFAULT_PAGE_SIZE, DEFAULT_RANK_CONSTANT, MAX_CURSOR_ANCHOR_CODE_POINTS, MAX_CURSOR_LENGTH, MAX_LINEAR_ALPHA, MAX_NESTING_DEPTH, MAX_PATTERN_VALUE_LIMIT, MAX_PREFIX_LENGTH, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_TOLERANCE, MIN_LINEAR_ALPHA, MIN_PATTERN_VALUE_LIMIT, MIN_RANK_CONSTANT, PREFIX_MAX_EXPANSIONS, PROTOTYPE_POLLUTION_KEYS, RESULT_WINDOW, VECTOR_PATTERN, extractVectorFieldsFromSchema, flattenSchema, isGeopointOrVectorType, isListBase, isQuantizationMode, isSingleStringFieldType, isStorageMode, isStringValuedBase, isWordIndexedBase, isWordIndexedFieldType, parsedTypeOf, requireValidFieldTypes, schemaFieldsOf, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion, validateVectorStorage, withSortableOption };