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

package/dist/{chunk-HVJYTKK7.mjs → chunk-THMSFOJO.mjs}

@@ -1,16 +1,15 @@
-import { cloneProjected, everyValueFacetConfig, mergeFacets, computeFacets, tokenizeOptions, getNestedValue, visitTokens, joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, textFieldsChanged, projectionKeepsField, setNestedValue, fnv1a, kWayMerge, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, getFieldValueByInternalId, undeclaredFilterField, requireValidOperands, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges, GEO_UNIT_METRES } from './chunk-QR4OKRVY.mjs';
-import { getLanguage, detectRuntime } from './chunk-KZTI25D3.mjs';
-import { schemaFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, isQuantizationMode, isStorageMode, requireValidFieldTypes, extractVectorFieldsFromSchema, VECTOR_PATTERN, parsedTypeOf, isListBase, VINCENTY_CONVERGENCE_THRESHOLD, EARTH_RADIUS_METERS, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-M6XF5HDE.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-LCCL6EEH.mjs';
-import { noteFallback } from './chunk-P2ZZN32C.mjs';
-import { VALID_HNSW_METRICS } from './chunk-IFBKLBGB.mjs';
-import { GrowableUint32, patternSearchModule } from './chunk-3HQPUCCT.mjs';
+import { getLanguage, detectRuntime } from './chunk-4MQ5F4IL.mjs';
+import { tokenizeOptions, getNestedValue, visitTokens, joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, computeFacets, cloneProjected, textFieldsChanged, projectionKeepsField, setNestedValue, fnv1a, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, everyValueFacetConfig, mergeFacets, getFieldValueByInternalId, undeclaredFilterField, requireValidOperands, kWayMerge, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges, GEO_UNIT_METRES } from './chunk-3YKWSO54.mjs';
+import { schemaFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, encodeDocument, extractVectorFieldsFromSchema, MAX_DOC_ID_LENGTH, parsedTypeOf, isListBase, VINCENTY_CONVERGENCE_THRESHOLD, EARTH_RADIUS_METERS, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-AK3BLGCI.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, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, requireWholeNeighbourLists, topLayerInParts, 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-WVDFG45M.mjs';
+import { MAX_M, noteFallback, EARLIER_RELEASE_MIN_M, MIN_M } from './chunk-PU43WDY4.mjs';
+import { GrowableUint32, patternSearchModule } from './chunk-XW25X6AU.mjs';
 import { bitsetHas, createBitSet, bitsetSet, bitsetOrInto, bitsetAndNotInto, bitsetAndInto, PATTERN_RUN_CODE_POINTS, bitsetFromSet, bitsetIsEmpty, bitsetAnd, bitsetNot } from './chunk-ZKRV5M2P.mjs';
-import { compareCodePoints, appendFoldedCodePoint, toReducedSortValue, readSortField, compareComparableValues, defaultSortMode, truncateSortString, SORT_VALUE_MAX_CODE_POINTS } from './chunk-LJYTW7GT.mjs';
-import { NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
+import { compareCodePoints, appendFoldedCodePoint, toReducedSortValue, readSortField, defaultSortMode, compareComparableValues, truncateSortString, SORT_VALUE_MAX_CODE_POINTS } from './chunk-LJYTW7GT.mjs';
+import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 import { totalmem } from 'os';
 import { getHeapStatistics } from 'v8';
-import { encode, decode } from '@msgpack/msgpack';
+import { decode } from '@msgpack/msgpack';
 
 var MEGABYTE_BYTES = 1048576;
 var IN_MEGABYTES = /^--max-old-space-size=(\d+)$/;
@@ -118,518 +117,6 @@ function resolveIndexAnalysis(config) {
     customTokenizer: typeof config.tokenizer === "string" ? getTokenizer(config.tokenizer) : config.tokenizer
   };
 }
-function metadataToWire(meta) {
-  const wire = {
-    index_name: meta.indexName,
-    schema: meta.schema,
-    language: meta.language,
-    partition_count: meta.partitionCount,
-    bm25_params: meta.bm25Params,
-    created_at: meta.createdAt,
-    engine_version: meta.engineVersion
-  };
-  if (meta.vectorFields) {
-    wire.vector_fields = meta.vectorFields;
-  }
-  if (isNonNegativeInteger(meta.documentCount) && Number.isSafeInteger(meta.documentCount)) {
-    wire.document_count = meta.documentCount;
-  }
-  if (meta.embedding) {
-    wire.embedding = meta.embedding.adapter !== void 0 ? { adapter: meta.embedding.adapter, fields: meta.embedding.fields } : { fields: meta.embedding.fields };
-  }
-  if (meta.surfaceForms !== void 0) {
-    wire.surface_forms_enabled = meta.surfaceForms;
-  }
-  if (meta.analysisRevision !== void 0) {
-    wire.analysis_revision = meta.analysisRevision;
-  }
-  if (meta.tokenizer !== void 0) {
-    wire.tokenizer = meta.tokenizer;
-  }
-  if (meta.stopWords !== void 0) {
-    wire.stop_words = meta.stopWords;
-  }
-  if (meta.stopWordList !== void 0) {
-    wire.stop_word_list = meta.stopWordList;
-  }
-  if (meta.partitionLimits !== void 0) {
-    wire.partition_limits = {
-      ...meta.partitionLimits.maxDocsPerPartition !== void 0 ? { max_docs_per_partition: meta.partitionLimits.maxDocsPerPartition } : {},
-      ...meta.partitionLimits.maxPartitions !== void 0 ? { max_partitions: meta.partitionLimits.maxPartitions } : {},
-      ...meta.partitionLimits.watermark !== void 0 ? { watermark: meta.partitionLimits.watermark } : {}
-    };
-  }
-  if (meta.defaultScoring !== void 0) {
-    wire.default_scoring = meta.defaultScoring;
-  }
-  if (meta.trackPositions !== void 0) {
-    wire.track_positions = meta.trackPositions;
-  }
-  if (meta.strict !== void 0) {
-    wire.strict = meta.strict;
-  }
-  if (meta.required !== void 0) {
-    wire.required = meta.required;
-  }
-  if (meta.vectorPromotion !== void 0) {
-    const promotion = meta.vectorPromotion;
-    wire.vector_promotion = {
-      ...promotion.threshold !== void 0 ? { threshold: promotion.threshold } : {},
-      ...promotion.filterThreshold !== void 0 ? { filter_threshold: promotion.filterThreshold } : {},
-      ...promotion.hnswConfig !== void 0 ? {
-        hnsw_config: {
-          ...promotion.hnswConfig.m !== void 0 ? { m: promotion.hnswConfig.m } : {},
-          ...promotion.hnswConfig.efConstruction !== void 0 ? { ef_construction: promotion.hnswConfig.efConstruction } : {},
-          ...promotion.hnswConfig.metric !== void 0 ? { metric: promotion.hnswConfig.metric } : {}
-        }
-      } : {},
-      ...promotion.quantization !== void 0 ? { quantization: promotion.quantization } : {},
-      ...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;
-  }
-  if (meta.heldPartitions !== void 0) {
-    wire.held_partitions = meta.heldPartitions;
-  }
-  return wire;
-}
-function wireToMetadata(raw) {
-  const meta = {
-    indexName: raw.index_name,
-    schema: raw.schema ?? {},
-    language: raw.language ?? "english",
-    partitionCount: raw.partition_count ?? 1,
-    bm25Params: raw.bm25_params ?? { k1: 1.2, b: 0.75 },
-    createdAt: raw.created_at ?? 0,
-    engineVersion: raw.engine_version ?? "0.0.0"
-  };
-  if (raw.vector_fields) {
-    for (const [fieldPath, field] of Object.entries(raw.vector_fields)) {
-      if (!isQuantizationMode(field.quantization)) {
-        throw new NarsilError(
-          ErrorCodes.CONFIG_INVALID,
-          `Index metadata names a vector quantization "${String(field.quantization)}" for "${fieldPath}" this engine does not read`,
-          { fieldPath, quantization: field.quantization }
-        );
-      }
-    }
-    meta.vectorFields = raw.vector_fields;
-  }
-  if (isNonNegativeInteger(raw.document_count) && Number.isSafeInteger(raw.document_count)) {
-    meta.documentCount = raw.document_count;
-  }
-  if (raw.embedding && typeof raw.embedding === "object" && typeof raw.embedding.fields === "object") {
-    meta.embedding = typeof raw.embedding.adapter === "string" ? { adapter: raw.embedding.adapter, fields: raw.embedding.fields } : { fields: raw.embedding.fields };
-  }
-  if (typeof raw.surface_forms_enabled === "boolean") {
-    meta.surfaceForms = raw.surface_forms_enabled;
-  }
-  if (typeof raw.analysis_revision === "string") {
-    meta.analysisRevision = raw.analysis_revision;
-  }
-  if (typeof raw.tokenizer === "string") {
-    meta.tokenizer = raw.tokenizer;
-  }
-  if (typeof raw.stop_words === "string") {
-    meta.stopWords = raw.stop_words;
-  }
-  if (Array.isArray(raw.stop_word_list) && raw.stop_word_list.every((word) => typeof word === "string")) {
-    meta.stopWordList = raw.stop_word_list;
-  }
-  if (raw.partition_limits && typeof raw.partition_limits === "object") {
-    const limits = {
-      ...isPositiveInteger(raw.partition_limits.max_docs_per_partition) ? { maxDocsPerPartition: raw.partition_limits.max_docs_per_partition } : {},
-      ...isPositiveInteger(raw.partition_limits.max_partitions) ? { maxPartitions: raw.partition_limits.max_partitions } : {},
-      ...isWatermarkFraction(raw.partition_limits.watermark) ? { watermark: raw.partition_limits.watermark } : {}
-    };
-    if (Object.keys(limits).length > 0) {
-      meta.partitionLimits = limits;
-    }
-  }
-  if (raw.default_scoring === "local" || raw.default_scoring === "dfs" || raw.default_scoring === "broadcast") {
-    meta.defaultScoring = raw.default_scoring;
-  }
-  if (typeof raw.track_positions === "boolean") {
-    meta.trackPositions = raw.track_positions;
-  }
-  if (typeof raw.strict === "boolean") {
-    meta.strict = raw.strict;
-  }
-  if (Array.isArray(raw.required) && raw.required.every((field) => typeof field === "string")) {
-    meta.required = raw.required;
-  }
-  if (raw.vector_promotion && typeof raw.vector_promotion === "object") {
-    const promotion = raw.vector_promotion;
-    const hnsw = promotion.hnsw_config && typeof promotion.hnsw_config === "object" ? promotion.hnsw_config : void 0;
-    const metric = hnsw?.metric;
-    const restored = {};
-    const hnswConfig = {};
-    if (isPositiveInteger(hnsw?.m)) {
-      hnswConfig.m = hnsw?.m;
-    }
-    if (isPositiveInteger(hnsw?.ef_construction)) {
-      hnswConfig.efConstruction = hnsw?.ef_construction;
-    }
-    if (metric === "cosine" || metric === "dotProduct" || metric === "euclidean") {
-      hnswConfig.metric = metric;
-    }
-    if (isPositiveInteger(promotion.threshold)) {
-      restored.threshold = promotion.threshold;
-    }
-    if (isSelectivityRatio(promotion.filter_threshold)) {
-      restored.filterThreshold = promotion.filter_threshold;
-    }
-    if (Object.keys(hnswConfig).length > 0) {
-      restored.hnswConfig = hnswConfig;
-    }
-    if (promotion.quantization !== void 0) {
-      if (!isQuantizationMode(promotion.quantization)) {
-        throw new NarsilError(
-          ErrorCodes.CONFIG_INVALID,
-          `Index metadata names a vector quantization "${String(promotion.quantization)}" this engine does not read`,
-          { quantization: promotion.quantization }
-        );
-      }
-      restored.quantization = promotion.quantization;
-    }
-    if (promotion.storage !== void 0) {
-      if (!isStorageMode(promotion.storage)) {
-        throw new NarsilError(
-          ErrorCodes.CONFIG_INVALID,
-          `Index metadata names a vector storage "${String(promotion.storage)}" this engine does not read`,
-          { storage: promotion.storage }
-        );
-      }
-      restored.storage = promotion.storage;
-    }
-    if (Object.keys(restored).length > 0) {
-      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;
-  }
-  if (Array.isArray(raw.held_partitions) && raw.held_partitions.every(isNonNegativeInteger)) {
-    meta.heldPartitions = raw.held_partitions;
-  }
-  return meta;
-}
-function isNonNegativeInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
-function isPositiveInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 1;
-}
-function isSelectivityRatio(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
-}
-function isWatermarkFraction(value) {
-  return typeof value === "number" && value > 0 && value <= 1;
-}
-function serializeMetadata(meta) {
-  const wire = metadataToWire(meta);
-  return encode(wire);
-}
-function deserializeMetadata(data) {
-  const raw = decode(data);
-  return wireToMetadata(raw);
-}
-
-// src/serialization/stored-vector-values.ts
-function dropStoredVectorValues(documents, schema) {
-  const vectorFieldPaths = [];
-  for (const [fieldPath, fieldType] of Object.entries(schema)) {
-    if (typeof fieldType === "string" && VECTOR_PATTERN.test(fieldType)) {
-      vectorFieldPaths.push(fieldPath);
-    }
-  }
-  if (vectorFieldPaths.length === 0) {
-    return;
-  }
-  for (const document of Object.values(documents)) {
-    for (const fieldPath of vectorFieldPaths) {
-      removeFieldAtPath(document.fields, fieldPath);
-    }
-  }
-}
-function removeFieldAtPath(fields, fieldPath) {
-  if (!fieldPath.includes(".")) {
-    delete fields[fieldPath];
-    return;
-  }
-  const segments = fieldPath.split(".");
-  let current = fields;
-  for (let i = 0; i < segments.length - 1; i += 1) {
-    const next = current[segments[i]];
-    if (next === null || typeof next !== "object") {
-      return;
-    }
-    current = next;
-  }
-  delete current[segments[segments.length - 1]];
-}
-
-// src/serialization/payload-v1/partition.ts
-function sanitizeSurfaceForms(raw) {
-  if (raw === void 0 || raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
-  const result = /* @__PURE__ */ Object.create(null);
-  let count = 0;
-  for (const [surface, value] of Object.entries(raw)) {
-    if (typeof value === "number") {
-      result[surface] = value;
-      count++;
-    } else if (Array.isArray(value) && typeof value[0] === "number" && typeof value[1] === "string") {
-      result[surface] = [value[0], value[1]];
-      count++;
-    }
-  }
-  return count > 0 ? result : void 0;
-}
-function patternIndexesToWire(pattern) {
-  if (pattern === void 0) return {};
-  const wire = /* @__PURE__ */ Object.create(null);
-  for (const [field, index] of Object.entries(pattern)) wire[field] = { doc_ids: index.docIds, runs: index.runs };
-  return { pattern: wire };
-}
-function isWireRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function corruptPatternEntry(field) {
-  return new NarsilError(
-    ErrorCodes.PERSISTENCE_LOAD_FAILED,
-    `The pattern entry of field "${field}" in this partition must hold a list of document IDs and a map of runs`,
-    { field }
-  );
-}
-function patternIndexesFromWire(raw) {
-  if (raw === void 0 || raw === null) return {};
-  if (!isWireRecord(raw)) {
-    throw new NarsilError(
-      ErrorCodes.PERSISTENCE_LOAD_FAILED,
-      "The pattern entry of this partition must be a map of fields"
-    );
-  }
-  const pattern = /* @__PURE__ */ Object.create(null);
-  for (const [field, index] of Object.entries(raw)) {
-    if (!isWireRecord(index) || !isWireRecord(index.runs) || !Array.isArray(index.doc_ids)) {
-      throw corruptPatternEntry(field);
-    }
-    const docIds = [];
-    for (const docId of index.doc_ids) {
-      if (typeof docId !== "string") throw corruptPatternEntry(field);
-      docIds.push(docId);
-    }
-    pattern[field] = { docIds, runs: index.runs };
-  }
-  return { pattern };
-}
-function validateHnswMetric(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
-    return value;
-  }
-  return void 0;
-}
-function wireToPartition(raw) {
-  const documents = {};
-  for (const [docId, doc] of Object.entries(raw.documents ?? {})) {
-    documents[docId] = {
-      fields: doc.fields,
-      fieldLengths: doc.field_lengths ?? {}
-    };
-  }
-  requireValidFieldTypes(raw.schema ?? {});
-  dropStoredVectorValues(documents, raw.schema ?? {});
-  const invertedIndex = {};
-  for (const [token, list] of Object.entries(raw.inverted_index ?? {})) {
-    invertedIndex[token] = {
-      docFrequency: list.doc_freq,
-      postings: (list.postings ?? []).map((p) => ({
-        docId: p.doc_id,
-        termFrequency: p.term_freq,
-        field: p.field,
-        positions: p.positions ?? []
-      }))
-    };
-  }
-  const numeric = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.numeric ?? {})) {
-    numeric[field] = entries.map((e) => ({ value: e.value, docId: e.doc_id }));
-  }
-  const boolean = {};
-  for (const [field, idx] of Object.entries(raw.field_indexes?.boolean ?? {})) {
-    boolean[field] = { trueDocs: idx.true_docs ?? [], falseDocs: idx.false_docs ?? [] };
-  }
-  const geopoint = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.geopoint ?? {})) {
-    geopoint[field] = entries.map((e) => ({ lat: e.lat, lon: e.lon, docId: e.doc_id }));
-  }
-  const vectorData = {};
-  for (const [field, data] of Object.entries(raw.vector_data ?? {})) {
-    vectorData[field] = {
-      dimension: data.dimension,
-      vectors: (data.vectors ?? []).map((v) => ({ docId: v.doc_id, vector: v.vector })),
-      hnswGraph: data.hnsw_graph ? {
-        entryPoint: data.hnsw_graph.entry_point,
-        maxLayer: data.hnsw_graph.max_layer,
-        m: data.hnsw_graph.m,
-        efConstruction: data.hnsw_graph.ef_construction,
-        metric: validateHnswMetric(data.hnsw_graph.metric),
-        nodes: data.hnsw_graph.nodes
-      } : null,
-      codes: data.codes ? { bits: data.codes.bits, centroid: data.codes.centroid, records: data.codes.records } : null
-    };
-  }
-  return {
-    indexName: raw.index_name,
-    partitionId: raw.partition_id,
-    totalPartitions: raw.total_partitions,
-    language: raw.language ?? "english",
-    schema: raw.schema ?? {},
-    docCount: raw.doc_count ?? 0,
-    avgDocLength: raw.avg_doc_length ?? 0,
-    documents,
-    invertedIndex,
-    fieldIndexes: {
-      numeric,
-      boolean,
-      enum: raw.field_indexes?.enum ?? {},
-      geopoint,
-      ...patternIndexesFromWire(raw.field_indexes?.pattern)
-    },
-    surfaceForms: sanitizeSurfaceForms(raw.surface_forms),
-    vectorData,
-    statistics: {
-      totalDocuments: raw.statistics?.total_documents ?? 0,
-      totalFieldLengths: raw.statistics?.total_field_lengths ?? {},
-      averageFieldLengths: raw.statistics?.average_field_lengths ?? {},
-      docFrequencies: raw.statistics?.doc_frequencies ?? {}
-    }
-  };
-}
-function deserializePayloadV1(data) {
-  const raw = decode(data);
-  return wireToPartition(raw);
-}
-
-// src/serialization/payload-v2.ts
-function encodeRawPayloadV2(wire) {
-  return encode(wire);
-}
-function validateHnswMetric2(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string" && VALID_HNSW_METRICS.has(value)) {
-    return value;
-  }
-  return void 0;
-}
-function storedDocumentsOf(raw) {
-  requireValidFieldTypes(raw.schema ?? {});
-  const documents = {};
-  for (const [docId, doc] of Object.entries(raw.documents ?? {})) {
-    documents[docId] = {
-      fields: doc.fields,
-      fieldLengths: doc.field_lengths ?? {}
-    };
-  }
-  dropStoredVectorValues(documents, raw.schema ?? {});
-  return documents;
-}
-function documentsOfPayloadV2(data) {
-  const raw = decode(data);
-  return { documents: storedDocumentsOf(raw), schema: raw.schema ?? {} };
-}
-function deserializePayloadV2(data) {
-  const raw = decode(data);
-  const documents = storedDocumentsOf(raw);
-  const fieldNames = raw.inverted_index?.field_names ?? [];
-  const invertedIndex = {};
-  for (const [token, list] of Object.entries(raw.inverted_index?.entries ?? {})) {
-    const count = list.ids.length;
-    const postings = new Array(count);
-    for (let i = 0; i < count; i++) {
-      postings[i] = {
-        docId: list.ids[i],
-        termFrequency: list.tf[i],
-        field: fieldNames[list.fi[i]] ?? "",
-        positions: list.pos ? list.pos[i] : []
-      };
-    }
-    invertedIndex[token] = {
-      docFrequency: list.df,
-      postings
-    };
-  }
-  const numeric = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.numeric ?? {})) {
-    numeric[field] = entries.map((e) => ({ value: e.value, docId: e.doc_id }));
-  }
-  const boolean = {};
-  for (const [field, idx] of Object.entries(raw.field_indexes?.boolean ?? {})) {
-    boolean[field] = { trueDocs: idx.true_docs ?? [], falseDocs: idx.false_docs ?? [] };
-  }
-  const geopoint = {};
-  for (const [field, entries] of Object.entries(raw.field_indexes?.geopoint ?? {})) {
-    geopoint[field] = entries.map((e) => ({ lat: e.lat, lon: e.lon, docId: e.doc_id }));
-  }
-  const vectorData = {};
-  for (const [field, data2] of Object.entries(raw.vector_data ?? {})) {
-    vectorData[field] = {
-      dimension: data2.dimension,
-      vectors: (data2.vectors ?? []).map((v) => ({ docId: v.doc_id, vector: v.vector })),
-      hnswGraph: data2.hnsw_graph ? {
-        entryPoint: data2.hnsw_graph.entry_point,
-        maxLayer: data2.hnsw_graph.max_layer,
-        m: data2.hnsw_graph.m,
-        efConstruction: data2.hnsw_graph.ef_construction,
-        metric: validateHnswMetric2(data2.hnsw_graph.metric),
-        nodes: data2.hnsw_graph.nodes
-      } : null,
-      codes: data2.codes ? { bits: data2.codes.bits, centroid: data2.codes.centroid, records: data2.codes.records } : null
-    };
-  }
-  return {
-    indexName: raw.index_name,
-    partitionId: raw.partition_id,
-    totalPartitions: raw.total_partitions,
-    language: raw.language ?? "english",
-    schema: raw.schema ?? {},
-    docCount: raw.doc_count ?? 0,
-    avgDocLength: raw.avg_doc_length ?? 0,
-    documents,
-    invertedIndex,
-    fieldIndexes: {
-      numeric,
-      boolean,
-      enum: raw.field_indexes?.enum ?? {},
-      geopoint,
-      ...patternIndexesFromWire(raw.field_indexes?.pattern)
-    },
-    surfaceForms: sanitizeSurfaceForms(raw.surface_forms),
-    vectorData,
-    statistics: {
-      totalDocuments: raw.statistics?.total_documents ?? 0,
-      totalFieldLengths: raw.statistics?.total_field_lengths ?? {},
-      averageFieldLengths: raw.statistics?.average_field_lengths ?? {},
-      docFrequencies: raw.statistics?.doc_frequencies ?? {}
-    }
-  };
-}
 
 // src/core/document-store.ts
 function detachedView(view) {
@@ -889,7 +376,7 @@ function createPostingList() {
     length: 0,
     docIds: [],
     termFrequencies: new Uint16Array(POSTING_LIST_INITIAL_CAPACITY),
-    fieldNameIndices: new Uint8Array(POSTING_LIST_INITIAL_CAPACITY),
+    fieldNameIndices: new Uint16Array(POSTING_LIST_INITIAL_CAPACITY),
     positions: null,
     docIdSet: /* @__PURE__ */ new Set(),
     deletedDocs: /* @__PURE__ */ new Set(),
@@ -903,7 +390,7 @@ function growTypedArrays(list) {
   const newTF = new Uint16Array(newCap);
   newTF.set(list.termFrequencies);
   list.termFrequencies = newTF;
-  const newFNI = new Uint8Array(newCap);
+  const newFNI = new Uint16Array(newCap);
   newFNI.set(list.fieldNameIndices);
   list.fieldNameIndices = newFNI;
 }
@@ -1148,7 +635,7 @@ function createInvertedIndex(fieldNameTable) {
         const docIdSet = /* @__PURE__ */ new Set();
         const docIds = new Array(count);
         const termFrequencies = new Uint16Array(count);
-        const fieldNameIndices = new Uint8Array(count);
+        const fieldNameIndices = new Uint16Array(count);
         let hasPositions = false;
         let validCount = 0;
         let totalTermFrequency = 0;
@@ -4931,7 +4418,7 @@ function encodeSegmentState(state) {
   const postingOffsets = new Uint32Array(state.invertedIdx.size() + 1);
   const postingDocIds = new Uint32Array(postings);
   const postingFrequencies = new Uint16Array(postings);
-  const postingFieldIndices = new Uint8Array(postings);
+  const postingFieldIndices = new Uint16Array(postings);
   const positionOffsets = hasPositions ? new Uint32Array(postings + 1) : null;
   const positionValues = hasPositions ? new Uint32Array(positions) : null;
   let postingCursor = 0;
@@ -5465,113 +4952,6 @@ function expandTermPrefix(state, surfacePrefix, stemmedToken, maxExpansions) {
   return entries.map((e) => e[0]);
 }
 
-// src/core/partition/wire-payload.ts
-function serializePartitionToWirePayloadV2(state, partitionId, indexName, totalPartitions, language, schema) {
-  const flatSchema = getFlatSchema(state, schema);
-  const flatSchemaStrings = {};
-  for (const [k, v] of Object.entries(flatSchema)) {
-    flatSchemaStrings[k] = v;
-  }
-  const wireDocs = /* @__PURE__ */ Object.create(null);
-  for (const [docId, stored] of state.docStore.all()) {
-    wireDocs[docId] = {
-      fields: stored.fields,
-      field_lengths: { ...stored.fieldLengths }
-    };
-  }
-  const resolver = state.docStore.resolver();
-  const fieldNames = [...state.fieldNameTable.names];
-  const wireEntries = /* @__PURE__ */ Object.create(null);
-  for (const token of state.invertedIdx.tokens()) {
-    const list = state.invertedIdx.lookup(token);
-    if (!list) continue;
-    const hasDeleted = list.deletedDocs.size > 0;
-    const ids = [];
-    const tf = [];
-    const fi = new Uint8Array(list.length);
-    const pos = list.positions ? [] : null;
-    let writeIdx = 0;
-    for (let i = 0; i < list.length; i++) {
-      if (hasDeleted && list.deletedDocs.has(list.docIds[i])) continue;
-      const externalId = resolver.toExternal(list.docIds[i]);
-      if (externalId === void 0) continue;
-      ids.push(externalId);
-      tf.push(list.termFrequencies[i]);
-      fi[writeIdx] = list.fieldNameIndices[i];
-      writeIdx++;
-      if (pos && list.positions) {
-        pos.push(list.positions[i]);
-      }
-    }
-    if (ids.length > 0) {
-      const finalFi = writeIdx < list.length ? fi.subarray(0, writeIdx) : fi;
-      wireEntries[token] = { df: list.docIdSet.size, ids, tf, fi: finalFi, pos };
-    }
-  }
-  const wireNumeric = {};
-  for (const [path, idx] of state.numericIndexes) {
-    wireNumeric[path] = idx.serialize().map((e) => ({
-      value: e.value,
-      doc_id: resolver.toExternal(e.docId) ?? ""
-    }));
-  }
-  const wireBoolean = {};
-  for (const [path, idx] of state.booleanIndexes) {
-    const s = idx.serialize();
-    wireBoolean[path] = {
-      true_docs: s.trueDocs.map((id) => resolver.toExternal(id) ?? "").filter((id) => id !== ""),
-      false_docs: s.falseDocs.map((id) => resolver.toExternal(id) ?? "").filter((id) => id !== "")
-    };
-  }
-  const wireEnum = {};
-  for (const [path, idx] of state.enumIndexes) {
-    const raw = idx.serialize();
-    const converted = /* @__PURE__ */ Object.create(null);
-    for (const [value, internalIds] of Object.entries(raw)) {
-      converted[value] = internalIds.map((id) => resolver.toExternal(id) ?? "").filter((id) => id !== "");
-    }
-    wireEnum[path] = converted;
-  }
-  const wireGeo = {};
-  for (const [path, idx] of state.geoIndexes) {
-    wireGeo[path] = idx.serialize().map((e) => ({
-      lat: e.lat,
-      lon: e.lon,
-      doc_id: resolver.toExternal(e.docId) ?? ""
-    }));
-  }
-  const serializedStats = state.stats.serialize();
-  return {
-    v: 2,
-    index_name: indexName,
-    partition_id: partitionId,
-    total_partitions: totalPartitions,
-    language,
-    schema: flatSchemaStrings,
-    doc_count: state.docStore.count(),
-    avg_doc_length: Object.values(serializedStats.averageFieldLengths).reduce((sum, v) => sum + v, 0),
-    documents: wireDocs,
-    inverted_index: {
-      field_names: fieldNames,
-      entries: wireEntries
-    },
-    field_indexes: {
-      numeric: wireNumeric,
-      boolean: wireBoolean,
-      enum: wireEnum,
-      geopoint: wireGeo,
-      ...patternIndexesToWire(serializePatternIndexes(state, schema))
-    },
-    surface_forms: state.surfaceRegistry.serialize(),
-    statistics: {
-      total_documents: serializedStats.totalDocuments,
-      total_field_lengths: serializedStats.totalFieldLengths,
-      average_field_lengths: serializedStats.averageFieldLengths,
-      doc_frequencies: serializedStats.docFrequencies
-    }
-  };
-}
-
 // src/core/partition/index.ts
 var statesByPartition = /* @__PURE__ */ new WeakMap();
 function readSegmentState(segment) {
@@ -5814,10 +5194,6 @@ function createPartitionIndex(partitionId, trackPositions = true) {
     serialize(indexName, totalPartitions, language, schema) {
       return serializePartition(state, partitionId, indexName, totalPartitions, language, schema);
     },
-    serializeToBytes(indexName, totalPartitions, language, schema) {
-      const wire = serializePartitionToWirePayloadV2(state, partitionId, indexName, totalPartitions, language, schema);
-      return encodeRawPayloadV2(wire);
-    },
     deserialize(data, schema) {
       deserializePartition(state, data, clearAll, schema);
     }
@@ -6340,10 +5716,6 @@ function createCompositePartition(partitionId, trackPositions = true, existingLi
       if (frozen.length === 0) return live.serialize(indexName, totalPartitions, language, schema);
       return composedScratch().serialize(indexName, totalPartitions, language, schema);
     },
-    serializeToBytes(indexName, totalPartitions, language, schema) {
-      if (frozen.length === 0) return live.serializeToBytes(indexName, totalPartitions, language, schema);
-      return composedScratch().serializeToBytes(indexName, totalPartitions, language, schema);
-    },
     deserialize(data, schema) {
       frozen.length = 0;
       invalidateDocFrequencies();
@@ -6774,10 +6146,6 @@ function createPartitionManager(indexName, config, language, router, initialPart
       validatePartitionId(partitionId);
       return partitions[partitionId].serialize(indexName, partitions.length, language.name, config.schema);
     },
-    serializePartitionToBytes(partitionId) {
-      validatePartitionId(partitionId);
-      return partitions[partitionId].serializeToBytes(indexName, partitions.length, language.name, config.schema);
-    },
     mergeSegment(partitionId, payload, documents) {
       validatePartitionId(partitionId);
       const partition = partitions[partitionId];
@@ -6903,6 +6271,9 @@ var WORKER_COPY_MIN_VECTORS = 1024;
 var BUILD_CHUNK_SIZE = 100;
 var REBUILD_REMOVED_RATIO = 0.2;
 var VECTOR_FILE_REPLACED_ABOVE_DEAD_SHARE = 0.2;
+var VECTOR_FILE_FIXED_OVERHEAD_BYTES = 65536;
+var VECTOR_FILE_STRING_HEADER_BYTES = 5;
+var VECTOR_FILE_CENTROID_BYTES_PER_COMPONENT = 9;
 var OSQ4_MIN_DIMENSION = 384;
 var DISK_ADOPTION_YIELD_INTERVAL = 4096;
 
@@ -6962,7 +6333,7 @@ function yieldToEventLoop() {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
 function* allLiveDocIds(state) {
-  for (const [docId] of state.store.entries()) {
+  for (const docId of state.store.docIds()) {
     if (state.tombstones.has(docId)) continue;
     yield docId;
   }
@@ -7083,14 +6454,6 @@ async function nodeThreadId() {
     return 0;
   }
 }
-async function isNodeMainThread() {
-  try {
-    const workerThreads = await import('worker_threads');
-    return workerThreads.isMainThread;
-  } catch {
-    return true;
-  }
-}
 
 // src/workers/entry-point.ts
 var DIST_SEGMENT = "/dist/";
@@ -7855,6 +7218,12 @@ function scheduleBuild(state) {
   }, 0);
 }
 
+// src/serialization/constants.ts
+var CHECKSUM_YIELD_CHUNK_BYTES = 4 * 1024 * 1024;
+var NATIVE_CRC32_MIN_BYTES = 16;
+var MAX_FILE_BYTES = 2147483647;
+var VALID_HNSW_METRICS = /* @__PURE__ */ new Set(["cosine", "dotProduct", "euclidean"]);
+
 // src/vector/vector-index/payload.ts
 var VECTOR_INDEX_PAYLOAD_VERSION = 3;
 var VECTOR_INDEX_PART_VECTORS = 65536;
@@ -7881,7 +7250,7 @@ function invalid(message, details) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isNonNegativeInteger2(value) {
+function isNonNegativeInteger(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
 function isSerializedGraph(value) {
@@ -7911,9 +7280,9 @@ function decodeVectorIndexPart(raw) {
     );
   }
   if (typeof raw.fieldName !== "string") invalid("fieldName must be a string");
-  if (!isNonNegativeInteger2(raw.dimension) || raw.dimension === 0) invalid("dimension must be a positive integer");
-  if (!isNonNegativeInteger2(raw.part)) invalid("part must be a non-negative integer");
-  if (!isNonNegativeInteger2(raw.parts) || raw.parts === 0 || raw.part >= raw.parts) {
+  if (!isNonNegativeInteger(raw.dimension) || raw.dimension === 0) invalid("dimension must be a positive integer");
+  if (!isNonNegativeInteger(raw.part)) invalid("part must be a non-negative integer");
+  if (!isNonNegativeInteger(raw.parts) || raw.parts === 0 || raw.part >= raw.parts) {
     invalid("parts must exceed part", { part: raw.part, parts: raw.parts });
   }
   if (!Array.isArray(raw.docIds) || !raw.docIds.every((docId) => typeof docId === "string")) {
@@ -7952,6 +7321,8 @@ function decodeVectorIndexParts(raw) {
 // src/vector/vector-index/checkpoint-payload.ts
 var VECTOR_FILE_PAYLOAD_VERSION = 1;
 var VECTOR_GRAPH_PAYLOAD_VERSION = 1;
+var VECTOR_GRAPH_PART_PAYLOAD_VERSION = 2;
+var VECTOR_GRAPH_PART_VECTORS = 16384;
 var VECTOR_FILE_MAX_VECTORS = VECTOR_INDEX_PART_VECTORS;
 var METRICS = ["cosine", "dotProduct", "euclidean"];
 function invalid2(payload, message, details) {
@@ -8002,14 +7373,16 @@ function decodeVectorFilePayload(raw) {
 function isMetric(value) {
   return METRICS.some((metric) => metric === value);
 }
-function decodeNumberedGraph(raw) {
+function decodeNumberedGraph(raw, minimumM) {
   const name = "vector graph";
   if (!isRecord2(raw)) invalid2(name, "each graph must be a map");
   const entryPoint = raw.entryPoint ?? null;
   if (entryPoint !== null && !isIntegerUpTo(entryPoint, 4294967295))
     invalid2(name, "entryPoint must be a uint32 or nil");
   if (!isIntegerUpTo(raw.maxLayer, 255)) invalid2(name, "maxLayer must be a uint8");
-  if (!isIntegerUpTo(raw.m, 65535) || raw.m === 0) invalid2(name, "m must be a positive uint16");
+  if (!isIntegerUpTo(raw.m, MAX_M) || raw.m < minimumM) {
+    invalid2(name, `m must be a whole number from ${minimumM} to ${MAX_M}`);
+  }
   if (!isIntegerUpTo(raw.efConstruction, 65535)) invalid2(name, "efConstruction must be a uint16");
   if (!isMetric(raw.metric)) invalid2(name, "metric must name a supported metric", { metric: raw.metric });
   if (!(raw.levels instanceof Uint8Array)) invalid2(name, "levels must be bytes");
@@ -8030,7 +7403,56 @@ function decodeVectorGraphPayload(raw) {
   requireVersion(name, raw.v, VECTOR_GRAPH_PAYLOAD_VERSION);
   if (typeof raw.fieldName !== "string") invalid2(name, "fieldName must be a string");
   if (!Array.isArray(raw.graphs)) invalid2(name, "graphs must be a list");
-  return { v: VECTOR_GRAPH_PAYLOAD_VERSION, fieldName: raw.fieldName, graphs: raw.graphs.map(decodeNumberedGraph) };
+  return {
+    v: VECTOR_GRAPH_PAYLOAD_VERSION,
+    fieldName: raw.fieldName,
+    graphs: raw.graphs.map((graph) => decodeNumberedGraph(graph, EARLIER_RELEASE_MIN_M))
+  };
+}
+function decodeVectorGraphPartPayload(raw) {
+  const name = "vector graph part";
+  if (!isRecord2(raw)) invalid2(name, "payload must be a map");
+  requireVersion(name, raw.v, VECTOR_GRAPH_PART_PAYLOAD_VERSION);
+  if (typeof raw.fieldName !== "string") invalid2(name, "fieldName must be a string");
+  if (!Array.isArray(raw.graphs)) invalid2(name, "graphs must be a list");
+  return {
+    v: VECTOR_GRAPH_PART_PAYLOAD_VERSION,
+    fieldName: raw.fieldName,
+    graphs: raw.graphs.map((graph) => decodeNumberedGraph(graph, MIN_M))
+  };
+}
+function sameGraphHeader(a, b) {
+  return a.entryPoint === b.entryPoint && a.maxLayer === b.maxLayer && a.m === b.m && a.efConstruction === b.efConstruction && a.metric === b.metric;
+}
+function assembleGraphParts(parts) {
+  const name = "vector graph part";
+  const first = parts[0];
+  if (first === void 0) invalid2(name, "a field that holds a graph must have at least one part");
+  const partLists = first.graphs.map(() => []);
+  for (let p = 0; p < parts.length; p++) {
+    const part = parts[p];
+    const isLast = p === parts.length - 1;
+    if (part.fieldName !== first.fieldName || part.graphs.length !== first.graphs.length) {
+      invalid2(name, `part ${p} lists other graphs than part 0`, { part: p });
+    }
+    for (let g = 0; g < part.graphs.length; g++) {
+      const graph = part.graphs[g];
+      if (!sameGraphHeader(graph, first.graphs[g]))
+        invalid2(name, `part ${p} gives graph ${g} other headers`, { part: p });
+      const levels = graph.levels.length;
+      const fits = isLast ? levels >= 1 && levels <= VECTOR_GRAPH_PART_VECTORS : levels === VECTOR_GRAPH_PART_VECTORS;
+      if (!fits) invalid2(name, `part ${p} gives graph ${g} ${levels} bytes of levels`, { part: p, levels });
+      partLists[g].push(graph);
+    }
+  }
+  const graphs = partLists.map((list) => ({ partSize: VECTOR_GRAPH_PART_VECTORS, parts: list }));
+  return { fieldName: first.fieldName, graphs };
+}
+function graphPartsOfEarlierPayload(payload) {
+  return {
+    fieldName: payload.fieldName,
+    graphs: payload.graphs.map((graph) => ({ partSize: Math.max(graph.levels.length, 1), parts: [graph] }))
+  };
 }
 
 // src/vector/vector-index/dead-bits.ts
@@ -8060,36 +7482,6 @@ function deadBitsWhere(count, isDeadAt) {
 }
 
 // src/vector/vector-index/persistence.ts
-function liveDocIds(state) {
-  const docIds = [];
-  for (let ordinal = 0; ordinal < state.store.slots; ordinal++) {
-    const docId = state.store.docIdForOrdinal(ordinal);
-    if (docId === void 0 || state.tombstones.has(docId)) continue;
-    docIds.push(docId);
-  }
-  return docIds;
-}
-function partVectors(state, docIds) {
-  const dimension = state.dimension;
-  const vectors = new Float32Array(docIds.length * dimension);
-  for (let i = 0; i < docIds.length; i++) {
-    const entry = state.store.get(docIds[i]);
-    if (entry !== void 0) vectors.set(entry.vector, i * dimension);
-  }
-  return vectors;
-}
-function graphsPerPart(state, partOf, parts) {
-  const sliced = Array.from({ length: parts }, () => []);
-  if (state.hnsw === null || partOf.size === 0) return sliced;
-  const graph = state.hnsw.serialize();
-  const nodesPerPart = Array.from({ length: parts }, () => []);
-  for (const node of graph.nodes) {
-    const part = partOf.get(node[0]);
-    if (part !== void 0) nodesPerPart[part].push(node);
-  }
-  for (let part = 0; part < parts; part++) sliced[part].push({ ...graph, nodes: nodesPerPart[part] });
-  return sliced;
-}
 function recordFor(state, quantizer, docId) {
   const record = quantizer.recordOf(docId);
   if (record !== void 0) return record;
@@ -8128,36 +7520,6 @@ function partCodes(state, docIds, centroid) {
   }
   return { bits: quantizer.bits, centroid, records };
 }
-function planParts(state) {
-  const docIds = liveDocIds(state);
-  const parts = Math.max(1, Math.ceil(docIds.length / VECTOR_INDEX_PART_VECTORS));
-  const partOf = /* @__PURE__ */ new Map();
-  for (let i = 0; i < docIds.length; i++) partOf.set(docIds[i], Math.floor(i / VECTOR_INDEX_PART_VECTORS));
-  const graphs = graphsPerPart(state, partOf, parts);
-  const centroid = codedCentroid(state);
-  return {
-    parts,
-    readPart(part) {
-      const start = part * VECTOR_INDEX_PART_VECTORS;
-      const slice = docIds.slice(start, start + VECTOR_INDEX_PART_VECTORS);
-      return {
-        v: VECTOR_INDEX_PAYLOAD_VERSION,
-        fieldName: state.fieldName,
-        dimension: state.dimension,
-        part,
-        parts,
-        docIds: slice,
-        graphs: graphs[part],
-        codes: partCodes(state, slice, centroid),
-        vectors: vectorsToBytes(partVectors(state, slice))
-      };
-    }
-  };
-}
-function serialize(state) {
-  const plan = planParts(state);
-  return Array.from({ length: plan.parts }, (_, part) => plan.readPart(part));
-}
 function splitSequences(parts) {
   const sequences = [];
   let current = null;
@@ -8210,7 +7572,7 @@ function restoreCodes(state, sequences) {
 }
 function restoreGraphs(state, graphs) {
   if (graphs.length === 0) {
-    for (const [docId] of state.store.entries()) {
+    for (const docId of state.store.docIds()) {
       if (!state.tombstones.has(docId)) state.buffer.add(docId);
     }
     return;
@@ -8233,14 +7595,14 @@ function restoreGraphs(state, graphs) {
       if (!restoredHnsw.has(nodeDocId) && state.store.has(nodeDocId)) restoredHnsw.insertNode(nodeDocId);
     }
   }
-  for (const [docId] of state.store.entries()) {
+  for (const docId of state.store.docIds()) {
     if (state.tombstones.has(docId)) continue;
     if (!restoredHnsw.has(docId)) state.buffer.add(docId);
   }
   if (state.buffer.size > restoredHnsw.size) {
     adoptGraph(state, null);
     state.buffer.clear();
-    for (const [docId] of state.store.entries()) {
+    for (const docId of state.store.docIds()) {
       if (!state.tombstones.has(docId)) state.buffer.add(docId);
     }
   }
@@ -8279,6 +7641,17 @@ function deserialize(state, parts) {
 
 // src/vector/vector-index/checkpoint-plan.ts
 var ORDINAL_HOLDS_NO_NUMBER = -1;
+function vectorsPerFile(dimension, codeBits) {
+  const recordBytes = codeBits === 1 || codeBits === 2 || codeBits === 4 || codeBits === 8 ? osqRecordBytes(dimension, codeBits) : 0;
+  const docIdBytes = VECTOR_FILE_STRING_HEADER_BYTES + MAX_DOC_ID_LENGTH * 3;
+  const perVector = dimension * 4 + recordBytes + docIdBytes;
+  const overhead = VECTOR_FILE_FIXED_OVERHEAD_BYTES + dimension * VECTOR_FILE_CENTROID_BYTES_PER_COMPONENT;
+  const fitting = Math.floor((MAX_FILE_BYTES - overhead) / perVector);
+  return Math.max(1, Math.min(VECTOR_FILE_MAX_VECTORS, fitting));
+}
+function fileCapacityOf(state) {
+  return vectorsPerFile(state.dimension, osqBitsOf(state.quantizationMode));
+}
 function calibrationOf(state) {
   if (codedCentroid(state) === null) return null;
   return Atomics.load(state.store.handles.header, STORE_CALIBRATION_GENERATION);
@@ -8318,10 +7691,10 @@ function filesWorthKeeping(state, listed, calibration, liveCounts) {
   }
   return kept;
 }
-function absorbSmallerPartialFiles(kept, liveCounts, vectorsToWrite) {
+function absorbSmallerPartialFiles(kept, liveCounts, vectorsToWrite, capacity) {
   let pending = vectorsToWrite;
   for (let index = kept.length - 1; index >= 0 && pending > 0; index--) {
-    if (kept[index].ordinals.length >= VECTOR_FILE_MAX_VECTORS) continue;
+    if (kept[index].ordinals.length >= capacity) continue;
     if (liveCounts[index] > pending) return;
     pending += liveCounts[index];
     kept.splice(index, 1);
@@ -8369,13 +7742,14 @@ function numberEveryVector(state, kept, written) {
   }
   return { numberOfOrdinal, ordinalOfNumber };
 }
-function graphOf(state, numbers) {
-  if (state.hnsw === null) return null;
-  return {
-    v: VECTOR_GRAPH_PAYLOAD_VERSION,
-    fieldName: state.fieldName,
-    graphs: [state.hnsw.serializeNumbered(numbers.numberOfOrdinal, numbers.ordinalOfNumber)]
-  };
+function graphPartsOf(state, numbers) {
+  if (state.hnsw === null || numbers.ordinalOfNumber.length === 0) return null;
+  const parts = state.hnsw.serializeNumbered(
+    numbers.numberOfOrdinal,
+    numbers.ordinalOfNumber,
+    VECTOR_GRAPH_PART_VECTORS
+  );
+  return parts.map((graph) => ({ v: VECTOR_GRAPH_PART_PAYLOAD_VERSION, fieldName: state.fieldName, graphs: [graph] }));
 }
 function readFile(state, planned, docIds, centroid) {
   const dimension = state.dimension;
@@ -8400,18 +7774,19 @@ function readFile(state, planned, docIds, centroid) {
     ordinals
   };
 }
-function planCheckpoint(state, listedKeys) {
+function planCheckpoint(state, listedKeys, rewritesGraph = false) {
   const signature = signatureOf(state);
   const calibration = signature.calibration;
   const trusted = registryMatches(state, listedKeys);
+  const capacity = fileCapacityOf(state);
   const liveCounts = [];
   const keptFiles = filesWorthKeeping(state, trusted ? state.savedFiles : [], calibration, liveCounts);
-  absorbSmallerPartialFiles(keptFiles, liveCounts, countOutside(state, liveCounts));
+  absorbSmallerPartialFiles(keptFiles, liveCounts, countOutside(state, liveCounts), capacity);
   const written = ordinalsOutsideOf(state, keptFiles);
   const writtenDocIds = written.map((ordinal) => state.store.docIdForOrdinal(ordinal) ?? "");
   const centroid = codedCentroid(state);
   const listedBefore = trusted && listedKeys !== null;
-  const unchanged = listedBefore && sameSignature(state.savedSignature, signature) && written.length === 0;
+  const unchanged = !rewritesGraph && listedBefore && sameSignature(state.savedSignature, signature) && written.length === 0;
   return {
     unchanged,
     keptFiles,
@@ -8421,12 +7796,12 @@ function planCheckpoint(state, listedKeys) {
       count: file.ordinals.length,
       dead: deadBitsOf(state, file)
     })),
-    newFiles: Math.ceil(written.length / VECTOR_FILE_MAX_VECTORS),
-    graph: unchanged ? null : graphOf(state, numberEveryVector(state, keptFiles, written)),
+    newFiles: Math.ceil(written.length / capacity),
+    graphParts: unchanged ? null : graphPartsOf(state, numberEveryVector(state, keptFiles, written)),
     signature,
     readNewFile(index) {
-      const start = index * VECTOR_FILE_MAX_VECTORS;
-      const end = start + VECTOR_FILE_MAX_VECTORS;
+      const start = index * capacity;
+      const end = start + capacity;
       return readFile(state, written.slice(start, end), writtenDocIds.slice(start, end), centroid);
     }
   };
@@ -8446,13 +7821,22 @@ function sameCentroid2(a, b) {
   return true;
 }
 function bufferEveryVectorOutsideTheGraph(state) {
-  for (const [docId] of state.store.entries()) {
+  for (const docId of state.store.docIds()) {
     if (state.tombstones.has(docId)) continue;
     if (state.hnsw === null || !state.hnsw.has(docId)) state.buffer.add(docId);
   }
 }
+function insertNodesOfLaterGraph(state, graph, later, ordinals) {
+  for (const part of later.parts) requireWholeNeighbourLists(part);
+  for (let number = 0; number < ordinals.length; number++) {
+    const ordinal = ordinals[number];
+    if (ordinal === NO_LIVE_VECTOR_AT_POSITION || topLayerInParts(later, number) < 0) continue;
+    const docId = state.store.docIdForOrdinal(ordinal);
+    if (docId !== void 0 && !graph.has(docId)) graph.insertOrdinal(ordinal);
+  }
+}
 function restoreGraph(state, payload, ordinalOfNumber) {
-  const first = payload?.graphs[0];
+  const first = payload?.graphs[0]?.parts[0];
   if (payload === null || first === void 0) {
     bufferEveryVectorOutsideTheGraph(state);
     return;
@@ -8463,17 +7847,9 @@ function restoreGraph(state, payload, ordinalOfNumber) {
     { m: first.m, efConstruction: first.efConstruction, metric: first.metric },
     state.osq ?? void 0
   );
-  graph.deserializeNumbered(first, ordinalOfNumber);
+  graph.deserializeNumbered(payload.graphs[0], ordinalOfNumber);
   adoptGraph(state, graph);
-  for (const later of payload.graphs.slice(1)) {
-    requireWholeNeighbourLists(later);
-    for (let number = 0; number < later.levels.length && number < ordinalOfNumber.length; number++) {
-      const ordinal = ordinalOfNumber[number];
-      if (later.levels[number] === 0 || ordinal === NO_LIVE_VECTOR_AT_POSITION) continue;
-      const docId = state.store.docIdForOrdinal(ordinal);
-      if (docId !== void 0 && !graph.has(docId)) graph.insertOrdinal(ordinal);
-    }
-  }
+  for (const later of payload.graphs.slice(1)) insertNodesOfLaterGraph(state, graph, later, ordinalOfNumber);
   bufferEveryVectorOutsideTheGraph(state);
   if (state.buffer.size <= graph.size) return;
   adoptGraph(state, null);
@@ -9154,12 +8530,11 @@ function createVectorIndex(fieldName, dimension, config, workerCopies = VECTOR_W
     },
     maintenanceStatus: () => maintenanceStatus(state),
     estimateMemoryBytes: () => estimateMemoryBytes(state),
-    serialize: () => serialize(state),
     deserialize: (parts) => {
       invalidateWorkerCopies(state);
       deserialize(state, parts);
     },
-    planCheckpoint: (listedKeys) => planCheckpoint(state, listedKeys),
+    planCheckpoint: (listedKeys, rewritesGraph) => planCheckpoint(state, listedKeys, rewritesGraph),
     recordCheckpoint: (plan, written) => recordCheckpoint(state, plan, written),
     restoreCheckpoint: (shape) => {
       invalidateWorkerCopies(state);
@@ -9277,11 +8652,46 @@ function createFrozenDocTable(idTable, lengthColumns, documents, tombstones) {
     }
   };
 }
+function removeFieldAtPath(document, fieldPath) {
+  const segments = fieldPath.split(".");
+  let current = document;
+  for (let i = 0; i < segments.length - 1; i += 1) {
+    const next = current[segments[i]];
+    if (next === null || typeof next !== "object" || Array.isArray(next)) return;
+    current = next;
+  }
+  delete current[segments[segments.length - 1]];
+}
+function decodeStoredDocument(bytes, discardedFields) {
+  let decoded;
+  try {
+    decoded = decode(bytes);
+  } catch (error) {
+    throw new NarsilError(
+      ErrorCodes.PERSISTENCE_LOAD_FAILED,
+      `A stored document is not MessagePack: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded) || decoded instanceof Uint8Array) {
+    throw new NarsilError(ErrorCodes.PERSISTENCE_LOAD_FAILED, "A stored document decodes to something other than a map");
+  }
+  const document = decoded;
+  if (discardedFields !== void 0) {
+    for (const fieldPath of discardedFields) removeFieldAtPath(document, fieldPath);
+  }
+  return document;
+}
+function decodeEveryStoredDocument(data) {
+  const count = data.offsets.length - 1;
+  for (let ordinal = 0; ordinal < count; ordinal++) {
+    decodeStoredDocument(data.blob.subarray(data.offsets[ordinal], data.offsets[ordinal + 1]), data.discardedFields);
+  }
+}
 function encodeDocumentTableData(documents) {
   const encoded = new Array(documents.length);
   let blobLength = 0;
   for (let ordinal = 0; ordinal < documents.length; ordinal++) {
-    const bytes = encode(documents[ordinal]);
+    const bytes = encodeDocument(documents[ordinal]);
     encoded[ordinal] = bytes;
     blobLength += bytes.length;
   }
@@ -9309,7 +8719,7 @@ function wrapEncodedDocumentTable(data) {
     docAt(ordinal) {
       let document = decoded[ordinal];
       if (document === void 0) {
-        document = decode(blob.slice(offsets[ordinal], offsets[ordinal + 1]));
+        document = decodeStoredDocument(blob.slice(offsets[ordinal], offsets[ordinal + 1]), data.discardedFields);
         decoded[ordinal] = document;
         decodedBytes += documentValueBytes(document);
       }
@@ -9944,6 +9354,9 @@ function wrapFrozenTokenTable(data) {
       }
       return token;
     },
+    byteLengthAt(sortedIndex) {
+      return offsets[sortedIndex + 1] - offsets[sortedIndex];
+    },
     payloadSlot(sortedIndex) {
       return payloadSlots[sortedIndex];
     },
@@ -10032,6 +9445,34 @@ function sharedSurfaceTable(payload) {
   if (table.counts.length === 0) return null;
   return { blob: sharedUint8(table.blob), offsets: sharedUint32(table.offsets), counts: sharedUint32(table.counts) };
 }
+function segmentArraysOf(payload, documentData) {
+  const tokenTable = encodeFrozenTokenTableData(payload.tokens, payload.docFrequencies);
+  const idTable = encodeExternalIdTableData(payload.docIds);
+  const surfaceTable = payload.surfaceForms === null ? null : encodeSurfaceTable(payload.surfaceForms);
+  return {
+    documentCount: payload.documentCount,
+    fieldNames: payload.fieldNames,
+    fieldLengthNames: payload.fieldLengthNames,
+    fieldLengthColumns: payload.fieldLengthColumns,
+    totalFieldLengths: payload.totalFieldLengths,
+    tokenTable,
+    idTable,
+    documentTable: documentData,
+    postingOffsets: payload.postingOffsets,
+    postingDocIds: payload.postingDocIds,
+    postingFrequencies: payload.postingFrequencies,
+    postingFieldIndices: payload.postingFieldIndices,
+    positionOffsets: payload.positionOffsets,
+    positionValues: payload.positionValues,
+    numeric: payload.numeric,
+    sizes: payload.sizes,
+    boolean: payload.boolean,
+    enums: payload.enums,
+    geo: payload.geo,
+    pattern: payload.pattern,
+    surfaceTable: surfaceTable === null || surfaceTable.counts.length === 0 ? null : surfaceTable
+  };
+}
 function freezeSegmentShared(payload, documents, segmentId) {
   if (typeof SharedArrayBuffer !== "function") return null;
   return freezeEncodedSegmentShared(payload, encodeDocumentTableData(documents), segmentId);
@@ -10060,12 +9501,13 @@ function freezeEncodedSegmentShared(payload, documentData, segmentId) {
     },
     documentTable: {
       blob: sharedUint8(documentData.blob),
-      offsets: sharedUint32(documentData.offsets)
+      offsets: sharedUint32(documentData.offsets),
+      ...documentData.discardedFields === void 0 ? {} : { discardedFields: documentData.discardedFields }
     },
     postingOffsets: sharedUint32(payload.postingOffsets),
     postingDocIds: sharedUint32(payload.postingDocIds),
     postingFrequencies: sharedUint16(payload.postingFrequencies),
-    postingFieldIndices: sharedUint8(payload.postingFieldIndices),
+    postingFieldIndices: sharedUint16(payload.postingFieldIndices),
     positionOffsets: payload.positionOffsets === null ? null : sharedUint32(payload.positionOffsets),
     positionValues: payload.positionValues === null ? null : sharedUint32(payload.positionValues),
     numeric: payload.numeric.map((entry) => ({
@@ -10248,6 +9690,133 @@ function createSharedFrozenSegment(snapshot) {
     snapshot
   );
 }
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var keyDecoder = new TextDecoder("utf-8", { fatal: true });
+function headerAt(view, offset) {
+  if (offset >= view.byteLength) return null;
+  const tag = view.getUint8(offset);
+  if (tag <= 127 || tag >= 224) return { headerBytes: 1, bodyBytes: 0, children: 0 };
+  if (tag <= 143) return { headerBytes: 1, bodyBytes: 0, children: (tag & 15) * 2 };
+  if (tag <= 159) return { headerBytes: 1, bodyBytes: 0, children: tag & 15 };
+  if (tag <= 191) return { headerBytes: 1, bodyBytes: tag & 31, children: 0 };
+  const lengthBytes = LENGTH_BYTES_BY_TAG.get(tag);
+  if (lengthBytes !== void 0) {
+    if (offset + 1 + lengthBytes > view.byteLength) return null;
+    const length = lengthBytes === 1 ? view.getUint8(offset + 1) : lengthBytes === 2 ? view.getUint16(offset + 1, false) : view.getUint32(offset + 1, false);
+    const headerBytes = 1 + lengthBytes;
+    if (ARRAY_TAGS.has(tag)) return { headerBytes, bodyBytes: 0, children: length };
+    if (MAP_TAGS.has(tag)) return { headerBytes, bodyBytes: 0, children: length * 2 };
+    return { headerBytes, bodyBytes: length + (EXT_TAGS.has(tag) ? 1 : 0), children: 0 };
+  }
+  const fixedBytes = FIXED_BODY_BYTES_BY_TAG.get(tag);
+  return fixedBytes === void 0 ? null : { headerBytes: 1, bodyBytes: fixedBytes, children: 0 };
+}
+var LENGTH_BYTES_BY_TAG = /* @__PURE__ */ new Map([
+  [196, 1],
+  [197, 2],
+  [198, 4],
+  [199, 1],
+  [200, 2],
+  [201, 4],
+  [217, 1],
+  [218, 2],
+  [219, 4],
+  [220, 2],
+  [221, 4],
+  [222, 2],
+  [223, 4]
+]);
+var ARRAY_TAGS = /* @__PURE__ */ new Set([220, 221]);
+var MAP_TAGS = /* @__PURE__ */ new Set([222, 223]);
+var EXT_TAGS = /* @__PURE__ */ new Set([199, 200, 201]);
+var FIXED_BODY_BYTES_BY_TAG = /* @__PURE__ */ new Map([
+  [192, 0],
+  [194, 0],
+  [195, 0],
+  [202, 4],
+  [203, 8],
+  [204, 1],
+  [205, 2],
+  [206, 4],
+  [207, 8],
+  [208, 1],
+  [209, 2],
+  [210, 4],
+  [211, 8],
+  [212, 2],
+  [213, 3],
+  [214, 5],
+  [215, 9],
+  [216, 17]
+]);
+function endOfValue(view, start) {
+  let offset = start;
+  let pending = 1;
+  while (pending > 0) {
+    const header = headerAt(view, offset);
+    if (header === null) return null;
+    offset += header.headerBytes + header.bodyBytes;
+    if (offset > view.byteLength) return null;
+    pending += header.children - 1;
+  }
+  return offset;
+}
+function stringKeyAt(bytes, view, offset) {
+  const header = headerAt(view, offset);
+  if (header === null || header.children !== 0) return null;
+  const tag = view.getUint8(offset);
+  const isString = tag >= 160 && tag <= 191 || tag === 217 || tag === 218 || tag === 219;
+  const end = offset + header.headerBytes + header.bodyBytes;
+  if (!isString || end > bytes.length) return null;
+  try {
+    return { key: keyDecoder.decode(bytes.subarray(offset + header.headerBytes, end)), end };
+  } catch {
+    return null;
+  }
+}
+function topLevelMapKeys(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const top = headerAt(view, 0);
+  if (top === null || top.bodyBytes !== 0) return null;
+  const tag = view.getUint8(0);
+  if (!(tag >= 128 && tag <= 143 || MAP_TAGS.has(tag))) return null;
+  const keys = /* @__PURE__ */ new Set();
+  let offset = top.headerBytes;
+  for (let pair = 0; pair < top.children / 2; pair += 1) {
+    const key = stringKeyAt(bytes, view, offset);
+    if (key === null) return null;
+    const valueEnd = endOfValue(view, key.end);
+    if (valueEnd === null) return null;
+    keys.add(key.key);
+    offset = valueEnd;
+  }
+  return keys;
+}
+function decodeMapWithoutFields(bytes, skippedFields) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const top = headerAt(view, 0);
+  if (top === null || top.children === 0 || top.bodyBytes !== 0) return null;
+  const tag = view.getUint8(0);
+  const isMap = tag >= 128 && tag <= 143 || MAP_TAGS.has(tag);
+  if (!isMap) return null;
+  const document = {};
+  let offset = top.headerBytes;
+  for (let pair = 0; pair < top.children / 2; pair += 1) {
+    const key = stringKeyAt(bytes, view, offset);
+    if (key === null || FORBIDDEN_KEYS.has(key.key)) return null;
+    const valueEnd = endOfValue(view, key.end);
+    if (valueEnd === null) return null;
+    if (!skippedFields.has(key.key)) {
+      try {
+        document[key.key] = decode(bytes.subarray(key.end, valueEnd));
+      } catch {
+        return null;
+      }
+    }
+    offset = valueEnd;
+  }
+  return offset === bytes.length ? document : null;
+}
 
 // src/core/partition/frozen/merge-fields.ts
 function indexByFieldPath(entries) {
@@ -10510,7 +10079,7 @@ function mergePostings2(inputs) {
   const postingOffsets = new Uint32Array(tokenCount + 1);
   const postingDocIds = new Uint32Array(totalPostings);
   const postingFrequencies = new Uint16Array(totalPostings);
-  const postingFieldIndices = new Uint8Array(totalPostings);
+  const postingFieldIndices = new Uint16Array(totalPostings);
   const positionOffsets = hasPositions ? new Uint32Array(totalPostings + 1) : null;
   const positionValues = hasPositions ? new Uint32Array(totalPositions) : null;
   let postingCursor = 0;
@@ -10584,11 +10153,15 @@ function mergePostings2(inputs) {
 }
 
 // src/core/partition/frozen/merge.ts
-function remapOf(segment, docIds) {
+function selectionKeeps(selection, ordinal) {
+  return selection.keep === void 0 ? !selection.segment.isTombstoned(ordinal) : selection.keep(ordinal);
+}
+function remapOf(selection, docIds) {
+  const { segment } = selection;
   const count = segment.arrays.documentCount;
   const remap = new Int32Array(count).fill(-1);
   for (let ordinal = 0; ordinal < count; ordinal++) {
-    if (segment.isTombstoned(ordinal)) continue;
+    if (!selectionKeeps(selection, ordinal)) continue;
     remap[ordinal] = docIds.length;
     docIds.push(segment.arrays.idTable.idAt(ordinal));
   }
@@ -10601,7 +10174,7 @@ function fieldNameIndex(fieldNames, name) {
   return fieldNames.length - 1;
 }
 function fieldIndexRemapOf(segment, fieldNames) {
-  const remap = new Uint8Array(segment.arrays.fieldNames.length);
+  const remap = new Uint16Array(segment.arrays.fieldNames.length);
   for (let i = 0; i < segment.arrays.fieldNames.length; i++) {
     remap[i] = fieldNameIndex(fieldNames, segment.arrays.fieldNames[i]);
   }
@@ -10647,20 +10220,34 @@ function mergeSurfaceForms2(inputs) {
   }
   return registry.size() === 0 ? null : registry.serialize();
 }
+function holdsADiscardedField(bytes, discardedFields) {
+  const keys = topLevelMapKeys(bytes);
+  if (keys === null) return true;
+  for (const fieldPath of discardedFields) {
+    const dot = fieldPath.indexOf(".");
+    if (keys.has(dot < 0 ? fieldPath : fieldPath.slice(0, dot))) return true;
+  }
+  return false;
+}
 function encodedDocumentsOf(input) {
   const table = input.segment.arrays.documentTable;
-  if (table !== null) {
-    return (ordinal) => table.blob.subarray(table.offsets[ordinal], table.offsets[ordinal + 1]);
-  }
   const encoded = new Array(input.remap.length);
-  return (ordinal) => {
+  const encodeOrdinal = (ordinal) => {
     let bytes = encoded[ordinal];
     if (bytes === void 0) {
-      bytes = encode(input.segment.documentSource.docAt(ordinal));
+      bytes = encodeDocument(input.segment.documentSource.docAt(ordinal));
       encoded[ordinal] = bytes;
     }
     return bytes;
   };
+  if (table === null) return encodeOrdinal;
+  const discardedFields = table.discardedFields;
+  return (ordinal) => {
+    if (encoded[ordinal] !== void 0) return encodeOrdinal(ordinal);
+    const stored = table.blob.subarray(table.offsets[ordinal], table.offsets[ordinal + 1]);
+    if (discardedFields === void 0 || !holdsADiscardedField(stored, discardedFields)) return stored;
+    return encodeOrdinal(ordinal);
+  };
 }
 function mergeDocuments2(inputs, documentCount) {
   const readers = inputs.map(encodedDocumentsOf);
@@ -10684,12 +10271,16 @@ function mergeDocuments2(inputs, documentCount) {
 }
 function mergeFrozenSegments(segments) {
   if (typeof SharedArrayBuffer !== "function") return null;
+  const merged = mergeSegmentContents(segments.map((segment) => ({ segment })));
+  return freezeEncodedSegmentShared(merged.payload, merged.documents);
+}
+function mergeSegmentContents(selections) {
   const docIds = [];
   const fieldNames = [];
-  const inputs = segments.map((segment) => ({
-    segment,
-    remap: remapOf(segment, docIds),
-    fieldIndexRemap: fieldIndexRemapOf(segment, fieldNames)
+  const inputs = selections.map((selection) => ({
+    segment: selection.segment,
+    remap: remapOf(selection, docIds),
+    fieldIndexRemap: fieldIndexRemapOf(selection.segment, fieldNames)
   }));
   const documentCount = docIds.length;
   const postings = mergePostings2(inputs);
@@ -10712,7 +10303,7 @@ function mergeFrozenSegments(segments) {
     surfaceForms: mergeSurfaceForms2(inputs),
     ...mergeFieldIndexes2(inputs)
   };
-  return freezeEncodedSegmentShared(payload, mergeDocuments2(inputs, documentCount));
+  return { payload, documents: mergeDocuments2(inputs, documentCount) };
 }
 
 // src/core/partition/segment-postings.ts
@@ -10826,7 +10417,7 @@ var TextPostings = class {
     const writeCursor = postingOffsets.slice(0, tokenCount);
     const postingDocIds = new Uint32Array(postings);
     const postingFrequencies = new Uint16Array(postings);
-    const postingFieldIndices = new Uint8Array(postings);
+    const postingFieldIndices = new Uint16Array(postings);
     const logRowOfPosting = new Uint32Array(postings);
     for (let row = 0; row < postings; row++) {
       const target = writeCursor[this.logToken.values[row]]++;
@@ -11559,4 +11150,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, getStopWords, getTokenizer, hasStopWords, hasTokenizer, isCompositePartition, isNodeMainThread, mergeFrozenSegments, missingWorkerEntry, nodeThreadId, readHeapStatistics, registerPatternSearch, registerStopWords, registerTokenizer, requirePatternSearchFor, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, serializeMetadata, spawnNodeWorker, splitWorkerBudget, workerResourceLimits };
+export { CHECKSUM_YIELD_CHUNK_BYTES, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, MAX_FILE_BYTES, NATIVE_CRC32_MIN_BYTES, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VALID_HNSW_METRICS, VECTOR_FILE_MAX_VECTORS, VECTOR_FILE_PAYLOAD_VERSION, assembleGraphParts, buildSegmentPayload, bytesToVectors, countDead, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeEveryStoredDocument, decodeMapWithoutFields, decodeStoredDocument, decodeVectorFilePayload, decodeVectorGraphPartPayload, decodeVectorGraphPayload, decodeVectorIndexParts, encodeSegmentState, freezeSegmentShared, generateId, getStopWords, getTokenizer, graphPartsOfEarlierPayload, hasStopWords, hasTokenizer, isCompositePartition, isDead, mergeFrozenSegments, mergeSegmentContents, missingWorkerEntry, nodeThreadId, partitionStateOf, readHeapStatistics, registerPatternSearch, registerStopWords, registerTokenizer, requirePatternSearchFor, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, segmentArraysOf, selectionKeeps, spawnNodeWorker, splitWorkerBudget, survivorDocumentsOf, vectorsPerFile, vectorsToBytes, workerResourceLimits };