@delali/narsil 0.2.4-next.51 → 0.2.4-next.54

package/dist/{chunk-XE6XR2OE.mjs → chunk-D2S642IV.mjs}

@@ -1,4 +1,4 @@
-import { DEFAULT_PAGE_SIZE } from './chunk-CBLS46IE.mjs';
+import { DEFAULT_PAGE_SIZE } from './chunk-L225SHNB.mjs';
 
 // src/engine/constants.ts
 var MIN_DOCUMENTS_FOR_SEGMENTS = 64;
@@ -6,6 +6,8 @@ var BATCH_CHUNK_SIZE = 1e3;
 var DEFAULT_LIMIT = DEFAULT_PAGE_SIZE;
 var DEFAULT_OFFSET = 0;
 var INDEX_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var ABSOLUTE_WINDOWS_PATH_PATTERN = /^[a-zA-Z]:[\\/]/;
+var MODULE_URL_SCHEME_PATTERN = /^(file|https?|data|node):/;
 var MAX_INDEX_NAME_LENGTH = 255;
 var MAX_DOC_ID_LENGTH = 512;
 var MIN_SWEEP_INTERVAL_MS = 100;
@@ -20,4 +22,4 @@ var SUGGEST_OVERSAMPLE_FACTOR = 1.5;
 var SUGGEST_OVERSAMPLE_PADDING = 10;
 var MAX_SUGGEST_SCATTER_LIMIT = Math.ceil(MAX_SUGGEST_LIMIT * SUGGEST_OVERSAMPLE_FACTOR) + SUGGEST_OVERSAMPLE_PADDING;
 
-export { BATCH_CHUNK_SIZE, DEFAULT_LIMIT, DEFAULT_OFFSET, DEFAULT_SUGGEST_LIMIT, FOREIGN_STATS_TTL_MS, HEAP_PRESSURE_REARM_FRACTION, HEAP_PRESSURE_WARNING_FRACTION, INDEX_NAME_PATTERN, MAX_DOC_ID_LENGTH, MAX_INDEX_NAME_LENGTH, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, MAX_SWEEP_INTERVAL_MS, MIN_DOCUMENTS_FOR_SEGMENTS, MIN_SWEEP_INTERVAL_MS, STATISTICS_BROADCAST_INTERVAL_MS, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING };
+export { ABSOLUTE_WINDOWS_PATH_PATTERN, BATCH_CHUNK_SIZE, DEFAULT_LIMIT, DEFAULT_OFFSET, DEFAULT_SUGGEST_LIMIT, FOREIGN_STATS_TTL_MS, HEAP_PRESSURE_REARM_FRACTION, HEAP_PRESSURE_WARNING_FRACTION, INDEX_NAME_PATTERN, MAX_DOC_ID_LENGTH, MAX_INDEX_NAME_LENGTH, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, MAX_SWEEP_INTERVAL_MS, MIN_DOCUMENTS_FOR_SEGMENTS, MIN_SWEEP_INTERVAL_MS, MODULE_URL_SCHEME_PATTERN, STATISTICS_BROADCAST_INTERVAL_MS, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING };

package/dist/{chunk-P4ELXVJQ.mjs → chunk-FRQVMFY7.mjs}

@@ -1,4 +1,5 @@
 // src/errors.ts
+var NARSIL_ERROR_MARKER = /* @__PURE__ */ Symbol.for("@delali/narsil.NarsilError");
 var ErrorCodes = {
   SCHEMA_INVALID_TYPE: "SCHEMA_INVALID_TYPE",
   SCHEMA_DEPTH_EXCEEDED: "SCHEMA_DEPTH_EXCEEDED",
@@ -16,6 +17,7 @@ var ErrorCodes = {
   WORKER_CRASHED: "WORKER_CRASHED",
   WORKER_BUSY: "WORKER_BUSY",
   WORKER_TIMEOUT: "WORKER_TIMEOUT",
+  WORKER_ACTION_FAILED: "WORKER_ACTION_FAILED",
   PERSISTENCE_SAVE_FAILED: "PERSISTENCE_SAVE_FAILED",
   PERSISTENCE_LOAD_FAILED: "PERSISTENCE_LOAD_FAILED",
   PERSISTENCE_DELETE_FAILED: "PERSISTENCE_DELETE_FAILED",
@@ -135,8 +137,12 @@ var NarsilError = class extends Error {
     this.name = "NarsilError";
     this.code = code;
     this.details = details ?? {};
+    Object.defineProperty(this, NARSIL_ERROR_MARKER, { value: true });
   }
 };
+function isNarsilError(value) {
+  return typeof value === "object" && value !== null && NARSIL_ERROR_MARKER in value;
+}
 function createNarsilError(code, message, details) {
   return new NarsilError(code, message, details);
 }
@@ -144,4 +150,4 @@ function describeError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, createNarsilError, describeError };
+export { ClientErrorCodes, ErrorCodes, NarsilError, ServerErrorCodes, createNarsilError, describeError, isNarsilError };

package/dist/chunk-IFBKLBGB.mjs

@@ -0,0 +1,7 @@
+// src/serialization/constants.ts
+var CHECKSUM_TIMEOUT_MS = 12e4;
+var CHECKSUM_YIELD_CHUNK_BYTES = 4 * 1024 * 1024;
+var NATIVE_CRC32_MIN_BYTES = 16;
+var VALID_HNSW_METRICS = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
+
+export { CHECKSUM_TIMEOUT_MS, CHECKSUM_YIELD_CHUNK_BYTES, NATIVE_CRC32_MIN_BYTES, VALID_HNSW_METRICS };

package/dist/chunk-L225SHNB.mjs

@@ -0,0 +1,513 @@
+import { MAX_M } from './chunk-UTOFOJOR.mjs';
+import { NarsilError, ErrorCodes } from './chunk-FRQVMFY7.mjs';
+
+// src/schema/constants.ts
+var MAX_NESTING_DEPTH = 4;
+var MAX_DOCUMENT_NESTING_DEPTH = 32;
+
+// 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+)]$/;
+var FIELD_NAME_PATTERN = /^[A-Za-z0-9_]+$/;
+var RESERVED_ROOT_FIELDS = /* @__PURE__ */ new Set(["id"]);
+var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/schema/validator/schema.ts
+function validateSchemaFields(schema, depth, prefix) {
+  if (depth > MAX_NESTING_DEPTH) {
+    throw new NarsilError(
+      ErrorCodes.SCHEMA_DEPTH_EXCEEDED,
+      `Schema nesting exceeds the maximum depth of ${MAX_NESTING_DEPTH} at "${prefix}"`,
+      { path: prefix, maxDepth: MAX_NESTING_DEPTH }
+    );
+  }
+  for (const [field, type] of Object.entries(schema)) {
+    const path = prefix ? `${prefix}.${field}` : field;
+    if (PROTOTYPE_POLLUTION_KEYS.has(field)) {
+      throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, `Field name "${field}" is not allowed in a schema`, {
+        field,
+        path
+      });
+    }
+    if (!FIELD_NAME_PATTERN.test(field)) {
+      throw new NarsilError(
+        ErrorCodes.SCHEMA_INVALID_TYPE,
+        `Field name "${field}" contains characters that are not allowed; use letters, digits, and underscores only`,
+        { field, path }
+      );
+    }
+    if (depth === 1 && RESERVED_ROOT_FIELDS.has(field)) {
+      throw new NarsilError(
+        ErrorCodes.SCHEMA_INVALID_TYPE,
+        `Field "${field}" is reserved and cannot be defined in a schema`,
+        { field, path }
+      );
+    }
+    if (isPlainObject(type)) {
+      validateSchemaFields(type, depth + 1, path);
+      continue;
+    }
+    if (typeof type !== "string") {
+      throw new NarsilError(
+        ErrorCodes.SCHEMA_INVALID_TYPE,
+        `Field "${path}" has an invalid type definition: ${String(type)}`,
+        {
+          field: path,
+          type: String(type)
+        }
+      );
+    }
+    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
+    });
+  }
+}
+function validateSchema(schema) {
+  if (!isPlainObject(schema)) {
+    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must be a plain object", {
+      received: typeof schema
+    });
+  }
+  if (Object.keys(schema).length === 0) {
+    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_TYPE, "Schema must define at least one field");
+  }
+  validateSchemaFields(schema, 1, "");
+}
+function flattenRecursive(schema, prefix, result) {
+  for (const [field, type] of Object.entries(schema)) {
+    const path = prefix ? `${prefix}.${field}` : field;
+    if (isPlainObject(type)) {
+      flattenRecursive(type, path, result);
+    } else {
+      result[path] = type;
+    }
+  }
+}
+function flattenSchema(schema) {
+  const result = {};
+  flattenRecursive(schema, "", result);
+  return result;
+}
+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));
+    }
+  }
+  return result;
+}
+
+// src/schema/validator/field-values.ts
+function validateGeopoint(path, value) {
+  if (!isPlainObject(value)) {
+    throw new NarsilError(
+      ErrorCodes.SCHEMA_INVALID_GEOPOINT,
+      `Field "${path}" expected a geopoint object with lat and lon`,
+      {
+        field: path,
+        received: Array.isArray(value) ? "array" : typeof value
+      }
+    );
+  }
+  if (typeof value.lat !== "number" || typeof value.lon !== "number" || Number.isNaN(value.lat) || Number.isNaN(value.lon)) {
+    throw new NarsilError(ErrorCodes.SCHEMA_INVALID_GEOPOINT, `Field "${path}" geopoint requires numeric lat and lon`, {
+      field: path,
+      lat: Number.isNaN(value.lat) ? "NaN" : typeof value.lat,
+      lon: Number.isNaN(value.lon) ? "NaN" : typeof value.lon
+    });
+  }
+  if (value.lat < -90 || value.lat > 90) {
+    throw new NarsilError(
+      ErrorCodes.SCHEMA_INVALID_GEOPOINT,
+      `Field "${path}" geopoint lat must be between -90 and 90`,
+      {
+        field: path,
+        lat: value.lat
+      }
+    );
+  }
+  if (value.lon < -180 || value.lon > 180) {
+    throw new NarsilError(
+      ErrorCodes.SCHEMA_INVALID_GEOPOINT,
+      `Field "${path}" geopoint lon must be between -180 and 180`,
+      {
+        field: path,
+        lon: value.lon
+      }
+    );
+  }
+}
+function validateVector(path, value, expectedDimension) {
+  const isArray = Array.isArray(value);
+  const isFloat32 = value instanceof Float32Array;
+  if (!isArray && !isFloat32) {
+    throw new NarsilError(
+      ErrorCodes.DOC_VALIDATION_FAILED,
+      `Field "${path}" expected a vector (Array or Float32Array)`,
+      { field: path, received: typeof value }
+    );
+  }
+  const arr = value;
+  if (arr.length !== expectedDimension) {
+    throw new NarsilError(
+      ErrorCodes.DOC_VALIDATION_FAILED,
+      `Field "${path}" expected vector of dimension ${expectedDimension}, got ${arr.length}`,
+      { field: path, expected: expectedDimension, received: arr.length }
+    );
+  }
+  for (let i = 0; i < arr.length; i++) {
+    if (typeof arr[i] !== "number" || Number.isNaN(arr[i])) {
+      throw new NarsilError(
+        ErrorCodes.DOC_VALIDATION_FAILED,
+        `Field "${path}" vector element at index ${i} is not a valid number`,
+        { field: path, index: i, value: arr[i] }
+      );
+    }
+  }
+}
+function validateTypedArray(path, value, elementType) {
+  if (!Array.isArray(value)) {
+    throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected an array`, {
+      field: path,
+      received: typeof value
+    });
+  }
+  for (let i = 0; i < value.length; i++) {
+    const el = value[i];
+    if (typeof el !== elementType) {
+      throw new NarsilError(
+        ErrorCodes.DOC_VALIDATION_FAILED,
+        `Field "${path}" array element at index ${i} expected ${elementType}, got ${typeof el}`,
+        { field: path, index: i, expected: elementType, received: typeof el }
+      );
+    }
+    if (elementType === "number" && Number.isNaN(el)) {
+      throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" array element at index ${i} is NaN`, {
+        field: path,
+        index: i
+      });
+    }
+  }
+}
+function validateFieldValue(path, value, type) {
+  switch (type) {
+    case "string":
+    case SORTABLE_TEXT_FIELD_TYPE:
+      if (typeof value !== "string") {
+        throw new NarsilError(
+          ErrorCodes.DOC_VALIDATION_FAILED,
+          `Field "${path}" expected string, got ${typeof value}`,
+          {
+            field: path,
+            expected: "string",
+            received: typeof value
+          }
+        );
+      }
+      return;
+    case "number":
+      if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path}" expected a valid number`, {
+          field: path,
+          expected: "number",
+          received: Number.isNaN(value) ? "NaN" : typeof value
+        });
+      }
+      return;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        throw new NarsilError(
+          ErrorCodes.DOC_VALIDATION_FAILED,
+          `Field "${path}" expected boolean, got ${typeof value}`,
+          {
+            field: path,
+            expected: "boolean",
+            received: typeof value
+          }
+        );
+      }
+      return;
+    case "enum":
+      if (typeof value !== "string") {
+        throw new NarsilError(
+          ErrorCodes.DOC_VALIDATION_FAILED,
+          `Field "${path}" expected enum (string), got ${typeof value}`,
+          {
+            field: path,
+            expected: "enum",
+            received: typeof value
+          }
+        );
+      }
+      return;
+    case "geopoint":
+      validateGeopoint(path, value);
+      return;
+    case "string[]":
+      validateTypedArray(path, value, "string");
+      return;
+    case "number[]":
+      validateTypedArray(path, value, "number");
+      return;
+    case "boolean[]":
+      validateTypedArray(path, value, "boolean");
+      return;
+    case "enum[]":
+      validateTypedArray(path, value, "string");
+      return;
+    default: {
+      const vectorMatch = VECTOR_PATTERN.exec(type);
+      if (vectorMatch) {
+        validateVector(path, value, Number.parseInt(vectorMatch[1], 10));
+      }
+    }
+  }
+}
+
+// src/schema/validator/storable.ts
+var RESERVED_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function reject(path, reason) {
+  throw new NarsilError(ErrorCodes.DOC_VALIDATION_FAILED, `Field "${path === "" ? "(document)" : path}" ${reason}`, {
+    field: path
+  });
+}
+function isPlainObject2(value) {
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function walkStorable(value, path, depth, ancestors, skip) {
+  if (value === null || value === void 0) return;
+  const kind = typeof value;
+  if (kind === "string" || kind === "boolean") return;
+  if (kind === "number") return;
+  if (kind === "bigint" || kind === "symbol" || kind === "function") {
+    reject(path, `holds a ${kind}, which cannot be stored or recovered`);
+  }
+  const container = value;
+  if (container instanceof Date || container instanceof Uint8Array) return;
+  const isArray = Array.isArray(container);
+  if (!isArray && !isPlainObject2(container)) {
+    reject(
+      path,
+      "holds a value that does not survive storage; use plain objects, arrays, strings, numbers, booleans, dates, or Uint8Array bytes"
+    );
+  }
+  if (depth >= MAX_DOCUMENT_NESTING_DEPTH) {
+    reject(path, `nests deeper than ${MAX_DOCUMENT_NESTING_DEPTH} levels`);
+  }
+  if (ancestors.has(container)) {
+    reject(path, "refers back to one of its own ancestors");
+  }
+  ancestors.add(container);
+  if (isArray) {
+    const items = container;
+    for (let i = 0; i < items.length; i++) {
+      walkStorable(items[i], `${path}[${i}]`, depth + 1, ancestors, skip);
+    }
+  } else {
+    const record = container;
+    for (const key of Object.keys(record)) {
+      const keyPath = path === "" ? key : `${path}.${key}`;
+      if (RESERVED_OBJECT_KEYS.has(key)) {
+        reject(keyPath, "uses a reserved object key");
+      }
+      if (skip.has(keyPath)) continue;
+      walkStorable(record[key], keyPath, depth + 1, ancestors, skip);
+    }
+  }
+  ancestors.delete(container);
+}
+function assertStorableDocument(document, skipFieldPaths) {
+  walkStorable(document, "", 0, /* @__PURE__ */ new Set(), skipFieldPaths ?? /* @__PURE__ */ new Set());
+}
+
+// src/schema/validator/document.ts
+var vectorPathCache = /* @__PURE__ */ new WeakMap();
+function vectorFieldPaths(schema) {
+  let paths = vectorPathCache.get(schema);
+  if (paths !== void 0) return paths;
+  paths = /* @__PURE__ */ new Set();
+  const collect = (level, prefix) => {
+    for (const [field, type] of Object.entries(level)) {
+      const path = prefix === "" ? field : `${prefix}.${field}`;
+      if (typeof type === "string" && VECTOR_PATTERN.test(type)) {
+        paths?.add(path);
+      } else if (isPlainObject(type)) {
+        collect(type, path);
+      }
+    }
+  };
+  collect(schema, "");
+  vectorPathCache.set(schema, paths);
+  return paths;
+}
+function validateDocumentFields(doc, schema, prefix) {
+  for (const [field, type] of Object.entries(schema)) {
+    const path = prefix ? `${prefix}.${field}` : field;
+    const value = doc[field];
+    if (value === void 0 || value === null) continue;
+    if (isPlainObject(type)) {
+      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);
+      continue;
+    }
+    validateFieldValue(path, value, type);
+  }
+}
+function validateDocument(document, schema) {
+  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, "");
+}
+function collectExtraFields(doc, schema, prefix, extras) {
+  for (const key of Object.keys(doc)) {
+    if (key === "id") continue;
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (!(key in schema)) {
+      extras.push(path);
+      continue;
+    }
+    const schemaType = schema[key];
+    if (isPlainObject(schemaType) && isPlainObject(doc[key])) {
+      collectExtraFields(doc[key], schemaType, path, extras);
+    }
+  }
+}
+function validateDocumentStrict(document, schema) {
+  const extras = [];
+  collectExtraFields(document, schema, "", extras);
+  if (extras.length > 0) {
+    throw new NarsilError(
+      ErrorCodes.DOC_VALIDATION_FAILED,
+      `Document contains fields not defined in schema: ${extras.join(", ")}`,
+      { extraFields: extras }
+    );
+  }
+}
+function resolveNestedValue(document, path) {
+  if (!path.includes(".")) return document[path];
+  const segments = path.split(".");
+  let current = document;
+  for (const segment of segments) {
+    if (current === null || current === void 0 || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function validateRequiredFields(document, required) {
+  if (required.length === 0) return;
+  for (const field of required) {
+    const value = resolveNestedValue(document, field);
+    if (value === void 0 || value === null) {
+      throw new NarsilError(ErrorCodes.DOC_MISSING_REQUIRED_FIELD, `Document is missing required field "${field}"`, {
+        field
+      });
+    }
+  }
+}
+
+// src/schema/validator/vector-promotion.ts
+var QUANTIZATION_MODES = /* @__PURE__ */ new Set(["osq8", "osq4", "osq2", "osq1", "none"]);
+var STORAGE_MODES = /* @__PURE__ */ new Set(["memory", "disk"]);
+function fail(message, details) {
+  throw new NarsilError(ErrorCodes.CONFIG_INVALID, message, details);
+}
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && value >= 1;
+}
+function isQuantizationMode(value) {
+  return typeof value === "string" && QUANTIZATION_MODES.has(value);
+}
+function isStorageMode(value) {
+  return typeof value === "string" && STORAGE_MODES.has(value);
+}
+function validateVectorStorage(config, filesystemDurability) {
+  if (config?.storage === "disk" && !filesystemDurability) {
+    fail("vectorPromotion.storage 'disk' needs filesystem durability, because a checkpoint file holds the vectors", {
+      storage: config.storage
+    });
+  }
+}
+function validateVectorPromotion(config) {
+  if (config === void 0) return;
+  if (config.threshold !== void 0 && !isPositiveInteger(config.threshold)) {
+    fail("vectorPromotion.threshold must be a positive integer", { threshold: config.threshold });
+  }
+  const quantization = config.quantization;
+  if (quantization !== void 0 && !isQuantizationMode(quantization)) {
+    fail("vectorPromotion.quantization must be 'osq8', 'osq4', 'osq2', 'osq1', or 'none'", { quantization });
+  }
+  const storage = config.storage;
+  if (storage !== void 0 && !isStorageMode(storage)) {
+    fail("vectorPromotion.storage must be 'memory' or 'disk'", { storage });
+  }
+  const hnsw = config.hnswConfig;
+  if (hnsw === void 0) return;
+  if (hnsw.m !== void 0 && (!isPositiveInteger(hnsw.m) || hnsw.m > MAX_M)) {
+    fail(`vectorPromotion.hnswConfig.m must be a positive integer no greater than ${MAX_M}`, { m: hnsw.m });
+  }
+  if (hnsw.efConstruction !== void 0 && !isPositiveInteger(hnsw.efConstruction)) {
+    fail("vectorPromotion.hnswConfig.efConstruction must be a positive integer", {
+      efConstruction: hnsw.efConstruction
+    });
+  }
+  const metric = hnsw.metric;
+  if (metric !== void 0 && metric !== "cosine" && metric !== "dotProduct" && metric !== "euclidean") {
+    fail("vectorPromotion.hnswConfig.metric must be 'cosine', 'dotProduct', or 'euclidean'", { metric });
+  }
+}
+
+// src/search/constants.ts
+var RESULT_WINDOW = 1e4;
+var DEFAULT_PAGE_SIZE = 10;
+var MAX_CURSOR_LENGTH = 40960;
+var MAX_SORT_FIELDS = 8;
+var MAX_SORT_FIELD_NAME_LENGTH = 255;
+var MAX_CURSOR_ANCHOR_CODE_POINTS = 512;
+var PREFIX_MAX_EXPANSIONS = 50;
+
+export { DEFAULT_PAGE_SIZE, MAX_CURSOR_ANCHOR_CODE_POINTS, MAX_CURSOR_LENGTH, MAX_NESTING_DEPTH, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, PREFIX_MAX_EXPANSIONS, PROTOTYPE_POLLUTION_KEYS, RESULT_WINDOW, SORTABLE_TEXT_FIELD_TYPE, VECTOR_PATTERN, extractVectorFieldsFromSchema, flattenSchema, isQuantizationMode, isStorageMode, isTextFieldType, validateDocument, validateDocumentStrict, validateRequiredFields, validateSchema, validateVectorPromotion, validateVectorStorage };

package/dist/{chunk-MHE7YWAU.mjs → chunk-NTZYA3SJ.mjs}

@@ -1,6 +1,6 @@
-import { MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR } from './chunk-PIWKZPP7.mjs';
-import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN } from './chunk-XE6XR2OE.mjs';
-import { NarsilError, ErrorCodes } from './chunk-P4ELXVJQ.mjs';
+import { MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR } from './chunk-4NVPQ6S5.mjs';
+import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN } from './chunk-D2S642IV.mjs';
+import { NarsilError, ErrorCodes } from './chunk-FRQVMFY7.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 var INDEX_CONFIG_PREFIX = "_narsil/index/";

package/dist/{chunk-WYJXSLER.mjs → chunk-POWOTUKJ.mjs}

@@ -11,6 +11,7 @@ var KNOWN_ACTION_TYPES = [
   "createIndex",
   "loadVectorCopy",
   "dropVectorCopy",
+  "insertVectorOrdinals",
   "serveRequests",
   "stopServing",
   "dropIndex",
@@ -57,4 +58,9 @@ function isValidWorkerResponse(msg) {
   return true;
 }
 
-export { createRequestId, isValidWorkerAction, isValidWorkerResponse };
+// src/workers/thread-slot.ts
+function threadSlotOfWorker(workerId) {
+  return workerId + 1;
+}
+
+export { createRequestId, isValidWorkerAction, isValidWorkerResponse, threadSlotOfWorker };