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

package/dist/client.d.ts

@@ -1,10 +1,10 @@
-export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-CKF-9WLP.js';
-export { A as ASYNC_IMPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-B1wz2Zl0.js';
-export { C as CapabilitiesResponse, a as CreateIndexEmbedding, H as HttpIndexConfig, I as ImportError, b as ImportResult, M as MemoryStatsResponse, T as TaskListPage, c as TaskListQuery, d as TaskProgress, e as TaskRecord, f as TaskStatus, g as TaskType } from './tasks-BEiNxDRs.js';
-export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-xVrOCYTW.js';
-import './schema-d5Afu03A.js';
+export { C as ClientErrorCode, a as ClientErrorCodes, E as ErrorCode, b as ErrorCodes, N as NarsilError, c as NarsilErrorCode, S as ServerErrorCode, d as ServerErrorCodes, i as isNarsilError } from './memory-C7UMCMH3.js';
+export { A as ASYNC_IMPORT_CAPABILITY, E as ErrorEnvelope, I as INDEX_LIFECYCLE_CAPABILITY, R as REBUILD_ANALYSIS_CAPABILITY, S as SERVER_CAPABILITIES, T as TASK_CANCEL_CAPABILITY, a as TASK_FILTER_CAPABILITY } from './capabilities-Dt-7B4Wz.js';
+export { C as CapabilitiesResponse, a as CreateIndexEmbedding, H as HttpIndexConfig, I as ImportError, b as ImportResult, M as MemoryStatsResponse, T as TaskListPage, c as TaskListQuery, d as TaskProgress, e as TaskRecord, f as TaskStatus, g as TaskType } from './tasks-BZt_zes6.js';
+export { A as AdminOperations, B as BulkOperations, D as DocumentOperations, F as FetchFunction, I as ImportSource, a as IndexOperations, N as NarsilClient, b as NarsilClientOptions, P as PutResult, R as RequestOptions, S as SearchOperations, c as ServerOperations, d as ServerVersion, T as TaskOperations, W as WaitForTaskOptions, e as createNarsilClient } from './client-COek5GXK.js';
+import './schema-Bgzr4g7b.js';
 import './adapters-79OIa4xm.js';
-import './config-CSvCVtB7.js';
-import './config-CEeSV_Xo.js';
-import './types-DAK7mnUZ.js';
+import './config-rBpbgTw8.js';
+import './config-Dfanyqqt.js';
+import './types-gOUqhs2F.js';
 import './types-D5OwhtsQ.js';

package/dist/{config-CEeSV_Xo.d.ts → config-Dfanyqqt.d.ts}

@@ -1,6 +1,6 @@
 import { P as PersistenceAdapter, I as InvalidationAdapter, E as EmbeddingAdapter } from './adapters-79OIa4xm.js';
-import { Q as QueryParams, e as QueryResult } from './memory-CKF-9WLP.js';
-import { I as IndexConfig, A as AnyDocument } from './schema-d5Afu03A.js';
+import { Q as QueryParams, e as QueryResult } from './memory-C7UMCMH3.js';
+import { I as IndexConfig, A as AnyDocument } from './schema-Bgzr4g7b.js';
 
 /**
  * Hooks that the engine calls alongside its own work, so that an application

package/dist/{config-CSvCVtB7.d.ts → config-rBpbgTw8.d.ts}

@@ -1,5 +1,5 @@
-import { N as NarsilConfig } from './config-CEeSV_Xo.js';
-import { A as AllocationTable, N as NodeRole, a as NodeRegistration, C as ClusterCoordinator, b as NodeCapacity } from './types-DAK7mnUZ.js';
+import { N as NarsilConfig } from './config-Dfanyqqt.js';
+import { A as AllocationTable, N as NodeRole, a as NodeRegistration, C as ClusterCoordinator, b as NodeCapacity } from './types-gOUqhs2F.js';
 import { N as NodeTransport } from './types-D5OwhtsQ.js';
 
 /**

package/dist/direct-executor-GYJEKNV5.mjs

@@ -0,0 +1,12 @@
+export { createDirectExecutor } from './chunk-M76V3OGJ.mjs';
+import './chunk-HWQLTLNG.mjs';
+import './chunk-LMO5TJUS.mjs';
+import './chunk-653BNMAF.mjs';
+import './chunk-TGP5M5R7.mjs';
+import './chunk-YJDQ7NLA.mjs';
+import './chunk-ZJ4CSAB2.mjs';
+import './chunk-YNVIUGF5.mjs';
+import './chunk-IFBKLBGB.mjs';
+import './chunk-U2BKYEC7.mjs';
+import './chunk-OI42GWLR.mjs';
+import './chunk-USKFU7J5.mjs';

package/dist/distribution/coordinator/etcd.d.ts

@@ -1,5 +1,5 @@
-import { C as ClusterCoordinator } from '../../types-DAK7mnUZ.js';
-import '../../schema-d5Afu03A.js';
+import { C as ClusterCoordinator } from '../../types-gOUqhs2F.js';
+import '../../schema-Bgzr4g7b.js';
 import '../../adapters-79OIa4xm.js';
 
 /**

package/dist/distribution/coordinator/etcd.mjs

@@ -1,5 +1,5 @@
 import { MAX_NODE_ID_LENGTH, MAX_WATCHERS } from '../../chunk-ORBLD3EL.mjs';
-import { compareCodePoints } from '../../chunk-YMZCMH5M.mjs';
+import { compareCodePoints } from '../../chunk-OI42GWLR.mjs';
 import { NarsilError, ErrorCodes } from '../../chunk-USKFU7J5.mjs';
 import { decode, encode } from '@msgpack/msgpack';
 

package/dist/distribution/coordinator/in-memory.d.ts

@@ -1,5 +1,5 @@
-import { C as ClusterCoordinator } from '../../types-DAK7mnUZ.js';
-import '../../schema-d5Afu03A.js';
+import { C as ClusterCoordinator } from '../../types-gOUqhs2F.js';
+import '../../schema-Bgzr4g7b.js';
 import '../../adapters-79OIa4xm.js';
 
 /**

package/dist/distribution/coordinator/in-memory.mjs

@@ -1,5 +1,5 @@
 import { NODE_HEARTBEAT_TTL_MS } from '../../chunk-ORBLD3EL.mjs';
-import { compareCodePoints } from '../../chunk-YMZCMH5M.mjs';
+import { compareCodePoints } from '../../chunk-OI42GWLR.mjs';
 
 // src/distribution/coordinator/in-memory.ts
 var NODE_HEARTBEAT_PREFIX = "_narsil/node/";

package/dist/distribution.d.ts

@@ -1,12 +1,12 @@
-import { a as CreateIndexOptions, C as ClusterNamespace, b as ClusterNodeConfig } from './config-CSvCVtB7.js';
-export { c as ClusterControllerConfig, d as ClusterNodeInfo, e as ClusterQueryConfig, N as NodeReadiness, R as ReplicationConfig } from './config-CSvCVtB7.js';
-import { N as NarsilEventMap, a as Narsil } from './engine-77ErLy8P.js';
-import { B as BatchResult, L as ListParams, g as ListResult, j as SuggestParams, k as SuggestResult, Q as QueryParams, h as PreflightResult, f as IndexStats, P as PartitionStatsResult, M as MemoryStats, e as QueryResult } from './memory-CKF-9WLP.js';
-import { I as IndexConfig, A as AnyDocument, a as InsertOptions } from './schema-d5Afu03A.js';
-import { b as NodeCapacity, N as NodeRole } from './types-DAK7mnUZ.js';
-export { c as AllocationConstraints, d as AllocationEvent, A as AllocationTable, C as ClusterCoordinator, e as NodeEvent, a as NodeRegistration, P as PartitionAssignment, f as PartitionState, S as SchemaEvent, U as UnassignedReason } from './types-DAK7mnUZ.js';
+import { a as CreateIndexOptions, C as ClusterNamespace, b as ClusterNodeConfig } from './config-rBpbgTw8.js';
+export { c as ClusterControllerConfig, d as ClusterNodeInfo, e as ClusterQueryConfig, N as NodeReadiness, R as ReplicationConfig } from './config-rBpbgTw8.js';
+import { N as NarsilEventMap, a as Narsil } from './engine-CXKfmK7I.js';
+import { B as BatchResult, L as ListParams, g as ListResult, j as SuggestParams, k as SuggestResult, Q as QueryParams, h as PreflightResult, f as IndexStats, P as PartitionStatsResult, M as MemoryStats, e as QueryResult } from './memory-C7UMCMH3.js';
+import { I as IndexConfig, A as AnyDocument, a as InsertOptions } from './schema-Bgzr4g7b.js';
+import { b as NodeCapacity, N as NodeRole } from './types-gOUqhs2F.js';
+export { c as AllocationConstraints, d as AllocationEvent, A as AllocationTable, C as ClusterCoordinator, e as NodeEvent, a as NodeRegistration, P as PartitionAssignment, f as PartitionState, S as SchemaEvent, U as UnassignedReason } from './types-gOUqhs2F.js';
 export { L as ListenHandler, N as NodeTransport, R as RespondFn, T as TransportConfig, a as TransportMessage } from './types-D5OwhtsQ.js';
-import './config-CEeSV_Xo.js';
+import './config-Dfanyqqt.js';
 import './adapters-79OIa4xm.js';
 
 /**

package/dist/distribution.mjs

@@ -1,22 +1,22 @@
 import { MAX_MESSAGE_SIZE_BYTES } from './chunk-UNEEFTEU.mjs';
-import { validateIndexName, indexConfigKey, putIndexMetadata, getIndexMetadata } from './chunk-VTPLKNWI.mjs';
-import { requireKnownConfig, resolveRunnableConfig, createEngineCore, startEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, computeEntryChecksum, createEntryMessage, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-6IT3MH5M.mjs';
+import { validateIndexName, indexConfigKey, indexSettingsOf, putIndexMetadata, withPartitionCount, getIndexMetadata, getClusterIndexConfig } from './chunk-3JGWULDF.mjs';
+import { requireKnownConfig, resolveRunnableConfig, createEngineCore, startEngineCore, createNarsilFromCore, runEngineQueryStats, runEngineListDocuments, runEngineSuggest, runEnginePreflight, runEngineQuery, createEngineIndex, applyIndexEntry, applyDeleteEntry, validateEntryBatchPayload, createAckMessage, validateEntryPayload, validateForwardBatchPayload, createForwardBatchResultMessage, createForwardBatchMessage, validateForwardBatchResultPayload, createForwardMessage, validateReplicationEntry, computeEntryChecksum, createEntryMessage, createEntryBatchMessage, createInsyncConfirmMessage, validateAckPayload, createInsyncRemoveMessage, validateInsyncConfirmPayload, createInsyncAddMessage } from './chunk-VNMTB3KC.mjs';
 import { ReplicationMessageTypes, TransportErrorCodes, ClusterMessageTypes, QueryMessageTypes, TransportError } from './chunk-GCM3JFVA.mjs';
-import { providedDocId, MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR, WIRE_BATCH_BUDGET } from './chunk-YA52AC2V.mjs';
-import { generateId, deserializePayloadV2, createPartitionIndex, getLanguage, FILTER_EXPRESSION_KEYS, FIELD_FILTER_OPERATORS } from './chunk-BEWOA4VV.mjs';
-import './chunk-AV4IJKD2.mjs';
-import { now, listBindingOf, queryBindingOf, hitsKeptPerGroup, clampLimit, resolveHybridFusion, dedupePinnedEntries, foldGroupReducer } from './chunk-2BDG2IWP.mjs';
-import { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, MAX_INDEX_NAME_LENGTH, MAX_DOC_ID_LENGTH, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, INDEX_NAME_PATTERN } from './chunk-5JLSTECC.mjs';
-import { oversampledShardSize, resolveProjection, clampRowCount, sortSignatureOf, requireMatchingCursor, decodePageCursor, normalizeSort, sortModesOf, encodePageCursor, applyProjection, readSortValues, requireWithinResultWindow, fnv1a, sortSignatureEntry, MAX_FILTER_DEPTH, fnv1aUint32s, mergePartitionStats, MIN_POLYGON_POINTS } from './chunk-4VU5TWCR.mjs';
-import { DEFAULT_PAGE_SIZE, MAX_SORT_FIELDS, MAX_CURSOR_LENGTH, MAX_TOLERANCE, MAX_PREFIX_LENGTH, RESULT_WINDOW, MAX_NESTING_DEPTH } from './chunk-6TGZG2TV.mjs';
+import { providedDocId, MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR, WIRE_BATCH_BUDGET } from './chunk-FVLQ63B7.mjs';
+import { generateId, deserializePayloadV2, createPartitionIndex, FILTER_EXPRESSION_KEYS, FIELD_FILTER_OPERATORS } from './chunk-M76V3OGJ.mjs';
+import { getLanguage } from './chunk-HWQLTLNG.mjs';
+import { now, listBindingOf, queryBindingOf, hitsKeptPerGroup, clampLimit, resolveHybridFusion, dedupePinnedEntries, foldGroupReducer } from './chunk-P4DSQ6M4.mjs';
+import { DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, MAX_INDEX_NAME_LENGTH, MAX_DOC_ID_LENGTH, SUGGEST_OVERSAMPLE_FACTOR, SUGGEST_OVERSAMPLE_PADDING, INDEX_NAME_PATTERN } from './chunk-GIVAGD3Q.mjs';
+import { oversampledShardSize, resolveProjection, clampRowCount, sortSignatureOf, requireMatchingCursor, decodePageCursor, normalizeSort, sortModesOf, encodePageCursor, applyProjection, readSortValues, requireWithinResultWindow, fnv1a, sortSignatureEntry, MAX_FILTER_DEPTH, fnv1aUint32s, mergePartitionStats, MIN_POLYGON_POINTS } from './chunk-LMO5TJUS.mjs';
+import { validateSchema, DEFAULT_PAGE_SIZE, MAX_SORT_FIELDS, MAX_CURSOR_LENGTH, MAX_TOLERANCE, MAX_PREFIX_LENGTH, RESULT_WINDOW, MAX_NESTING_DEPTH } from './chunk-653BNMAF.mjs';
 import './chunk-TGP5M5R7.mjs';
-import './chunk-THYRHHO2.mjs';
+import './chunk-YJDQ7NLA.mjs';
 import { MIN_OVERSAMPLE } from './chunk-ZJ4CSAB2.mjs';
 import './chunk-YNVIUGF5.mjs';
 import { crc32 } from './chunk-3L4U6EJQ.mjs';
 import './chunk-IFBKLBGB.mjs';
 import './chunk-U2BKYEC7.mjs';
-import { compareCodePoints, toComparableSortValue, compareComparableKeys, isSortMode, SORT_MODES, compareSortValues } from './chunk-YMZCMH5M.mjs';
+import { compareCodePoints, toComparableSortValue, compareComparableKeys, isSortMode, SORT_MODES, compareSortValues } from './chunk-OI42GWLR.mjs';
 import './chunk-POWOTUKJ.mjs';
 import { ErrorCodes, NarsilError, describeError } from './chunk-USKFU7J5.mjs';
 import { encode, decode } from '@msgpack/msgpack';
@@ -3332,7 +3332,7 @@ async function dropRestoredIndexQuietly(engine, indexName, deps = {}) {
     );
   }
 }
-async function loadCoordinatorSchema(coordinator, indexName, primaryNodeId, abortPromise) {
+async function loadCoordinatorIndexConfig(coordinator, indexName, primaryNodeId, abortPromise) {
   let schema;
   try {
     const winner = await Promise.race([coordinator.getSchema(indexName), abortPromise]);
@@ -3359,7 +3359,35 @@ async function loadCoordinatorSchema(coordinator, indexName, primaryNodeId, abor
       )
     };
   }
-  return { schema };
+  let validSchema;
+  try {
+    validSchema = validateSchema(schema);
+  } catch (err) {
+    if (!(err instanceof NarsilError)) throw err;
+    return {
+      error: new NarsilError(err.code, `coordinator schema for index '${indexName}' is invalid: ${err.message}`, {
+        ...err.details,
+        indexName,
+        primaryNodeId
+      })
+    };
+  }
+  try {
+    const winner = await Promise.race([getClusterIndexConfig(coordinator, indexName, validSchema), abortPromise]);
+    if (winner === ABORT_SENTINEL) {
+      return "aborted";
+    }
+    return { config: winner };
+  } catch (err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    return {
+      error: new NarsilError(
+        err instanceof NarsilError ? err.code : ErrorCodes.SNAPSHOT_SYNC_SCHEMA_UNAVAILABLE,
+        `failed to read the coordinator index metadata for '${indexName}': ${cause}`,
+        { indexName, primaryNodeId, cause }
+      )
+    };
+  }
 }
 async function dropExistingIndex(engine, indexName, primaryNodeId) {
   try {
@@ -3602,8 +3630,8 @@ function streamFailureToError(failure) {
 }
 
 // src/distribution/cluster-node/bootstrap-sync/apply.ts
-async function applyLiveIncrementalSync(indexName, partitionId, target, entriesPayloads, expectedFirstSeqNo, localPrimaryTerm, coordinatorSchema, partitionCount, deps) {
-  const ensureResult = await ensureLocalIndexForIncremental(indexName, target, coordinatorSchema, partitionCount, deps);
+async function applyLiveIncrementalSync(indexName, partitionId, target, entriesPayloads, expectedFirstSeqNo, localPrimaryTerm, coordinatorConfig, partitionCount, deps) {
+  const ensureResult = await ensureLocalIndexForIncremental(indexName, target, coordinatorConfig, partitionCount, deps);
   if (ensureResult instanceof NarsilError) {
     return { ok: false, error: ensureResult };
   }
@@ -3626,7 +3654,7 @@ async function applyLiveIncrementalSync(indexName, partitionId, target, entriesP
     snapshotHeader: null
   };
 }
-async function applyLiveSnapshotSync(state, entry, indexName, partitionId, target, frameState, coordinatorSchema, partitionCount, deadline, deps) {
+async function applyLiveSnapshotSync(state, entry, indexName, partitionId, target, frameState, coordinatorConfig, partitionCount, deadline, deps) {
   const finalized = finalizeSnapshotStream(frameState.snapshotState);
   if (!finalized.ok) {
     return { ok: false, error: streamFailureToError(finalized) };
@@ -3653,7 +3681,7 @@ async function applyLiveSnapshotSync(state, entry, indexName, partitionId, targe
     partitionId,
     target,
     finalized.bytes,
-    coordinatorSchema,
+    coordinatorConfig,
     partitionCount,
     deadline,
     deps
@@ -3681,7 +3709,7 @@ async function applyLiveSnapshotSync(state, entry, indexName, partitionId, targe
     snapshotHeader: finalized.header
   };
 }
-async function restoreLiveSnapshotPartition(state, entry, indexName, partitionId, primaryNodeId, bytes, coordinatorSchema, partitionCount, deadline, deps) {
+async function restoreLiveSnapshotPartition(state, entry, indexName, partitionId, primaryNodeId, bytes, coordinatorConfig, partitionCount, deadline, deps) {
   const remainingMs = deadline - Date.now();
   if (remainingMs <= 0) {
     return new NarsilError(
@@ -3705,7 +3733,7 @@ async function restoreLiveSnapshotPartition(state, entry, indexName, partitionId
   }
   try {
     await withDeadline(
-      deps.restoreReplicationPartition(indexName, partitionId, bytes, coordinatorSchema, partitionCount),
+      deps.restoreReplicationPartition(indexName, partitionId, bytes, coordinatorConfig, partitionCount),
       remainingMs,
       indexName,
       "partition-restore"
@@ -3730,29 +3758,26 @@ async function restoreLiveSnapshotPartition(state, entry, indexName, partitionId
       primaryNodeId
     });
   }
-  const schemaError = validateRestoredSchema(deps.engine, indexName, primaryNodeId, coordinatorSchema);
+  const schemaError = validateRestoredSchema(deps.engine, indexName, primaryNodeId, coordinatorConfig.schema);
   if (schemaError !== null) {
     return schemaError;
   }
   return null;
 }
-async function ensureLocalIndexForIncremental(indexName, primaryNodeId, coordinatorSchema, partitionCount, deps) {
+async function ensureLocalIndexForIncremental(indexName, primaryNodeId, coordinatorConfig, partitionCount, deps) {
   const existing = deps.engine.listIndexes().find((idx) => idx.name === indexName);
   if (existing !== void 0) {
-    const validation = validateLocalSchema(deps.engine, indexName, primaryNodeId, coordinatorSchema);
+    const validation = validateLocalSchema(deps.engine, indexName, primaryNodeId, coordinatorConfig.schema);
     if (validation instanceof NarsilError) {
       return validation;
     }
     return validateLocalPartitionCount(deps.engine, indexName, primaryNodeId, partitionCount);
   }
   try {
-    await deps.engine.createIndex(indexName, {
-      schema: coordinatorSchema,
-      partitions: { maxPartitions: partitionCount }
-    });
+    await deps.engine.createIndex(indexName, withPartitionCount(coordinatorConfig, partitionCount));
   } catch (err) {
     if (err instanceof NarsilError && err.code === ErrorCodes.INDEX_ALREADY_EXISTS) {
-      const validation = validateLocalSchema(deps.engine, indexName, primaryNodeId, coordinatorSchema);
+      const validation = validateLocalSchema(deps.engine, indexName, primaryNodeId, coordinatorConfig.schema);
       if (validation instanceof NarsilError) {
         return validation;
       }
@@ -3839,7 +3864,7 @@ async function reportSyncedPosition(indexName, partitionId, target, knownSeqNo,
     }
   }
 }
-async function syncFromAnyTarget(state, entry, indexName, partitionId, primaryNodeId, targets, coordinatorSchema, partitionCount, deadline, deps, abortCheck) {
+async function syncFromAnyTarget(state, entry, indexName, partitionId, primaryNodeId, targets, coordinatorConfig, partitionCount, deadline, deps, abortCheck) {
   let lastError = new NarsilError(ErrorCodes.SNAPSHOT_SYNC_TRANSPORT_FAILED, "no live sync attempts were made", {
     indexName,
     partitionId,
@@ -3879,7 +3904,7 @@ async function syncFromAnyTarget(state, entry, indexName, partitionId, primaryNo
       indexName,
       partitionId,
       target,
-      coordinatorSchema,
+      coordinatorConfig,
       partitionCount,
       deadline,
       deps,
@@ -3899,7 +3924,7 @@ async function syncFromAnyTarget(state, entry, indexName, partitionId, primaryNo
   }
   return { ok: false, error: lastError };
 }
-async function syncFromTarget(state, entry, indexName, partitionId, target, coordinatorSchema, partitionCount, deadline, deps, abortCheck) {
+async function syncFromTarget(state, entry, indexName, partitionId, target, coordinatorConfig, partitionCount, deadline, deps, abortCheck) {
   const logState = readLocalLogState(indexName, partitionId, deps);
   const requestPayload = {
     indexName,
@@ -3963,7 +3988,7 @@ async function syncFromTarget(state, entry, indexName, partitionId, target, coor
       partitionId,
       target,
       frameState,
-      coordinatorSchema,
+      coordinatorConfig,
       partitionCount,
       deadline,
       deps
@@ -3977,7 +4002,7 @@ async function syncFromTarget(state, entry, indexName, partitionId, target, coor
       frameState.syncEntries,
       logState.lastSeqNo + 1,
       logState.lastPrimaryTerm,
-      coordinatorSchema,
+      coordinatorConfig,
       partitionCount,
       deps
     );
@@ -4046,13 +4071,13 @@ async function resolveLivePartitionCount(coordinator, indexName, partitionId, pr
   }
 }
 async function executeLiveBootstrapSync(state, entry, indexName, partitionId, primaryNodeId, deps, deadlineMs, deadline, abortCheck) {
-  const schemaResult = await loadCoordinatorSchema(deps.coordinator, indexName, primaryNodeId, entry.abortPromise);
-  if (schemaResult === "aborted") {
+  const configResult = await loadCoordinatorIndexConfig(deps.coordinator, indexName, primaryNodeId, entry.abortPromise);
+  if (configResult === "aborted") {
     surfaceAborted(deps, indexName, primaryNodeId);
     return false;
   }
-  if ("error" in schemaResult) {
-    surfaceError(deps, indexName, primaryNodeId, schemaResult.error);
+  if ("error" in configResult) {
+    surfaceError(deps, indexName, primaryNodeId, configResult.error);
     return false;
   }
   if (abortCheck()) {
@@ -4098,7 +4123,7 @@ async function executeLiveBootstrapSync(state, entry, indexName, partitionId, pr
     partitionId,
     primaryNodeId,
     targetsResult,
-    schemaResult.schema,
+    configResult.config,
     allocationResult.partitionCount,
     deadline,
     deps,
@@ -4135,15 +4160,15 @@ async function fetchSchemaAndPrepare(entry, indexName, primaryNodeId, deps) {
   if (entry.aborted) {
     return "aborted";
   }
-  const schemaResult = await loadCoordinatorSchema(deps.coordinator, indexName, primaryNodeId, entry.abortPromise);
-  if (schemaResult === "aborted") {
+  const configResult = await loadCoordinatorIndexConfig(deps.coordinator, indexName, primaryNodeId, entry.abortPromise);
+  if (configResult === "aborted") {
     return "aborted";
   }
-  if ("error" in schemaResult) {
-    surfaceError(deps, indexName, primaryNodeId, schemaResult.error);
+  if ("error" in configResult) {
+    surfaceError(deps, indexName, primaryNodeId, configResult.error);
     return null;
   }
-  return schemaResult.schema;
+  return configResult.config.schema;
 }
 async function applyRestore(state, entry, indexName, primaryNodeId, bytes, coordinatorSchema, deadline, deps) {
   const remainingMs = deadline - Date.now();
@@ -5193,13 +5218,14 @@ async function applyLocalReplicationEntry(core, entry) {
 async function createClusterLocalEngine(config, hooks) {
   requireKnownConfig(config);
   const runnableConfig = await resolveRunnableConfig(config);
-  const core = createEngineCore(runnableConfig, hooks);
+  const core = createEngineCore(runnableConfig, hooks, "partition");
   await startEngineCore(core, runnableConfig);
   core.orchestrator.shareMainThread();
   const engine = createNarsilFromCore(core, runnableConfig);
   const heldPartitions = createHeldPartitionRecord(core);
   return Object.assign(engine, {
-    createIndexWithUuid: (name, indexConfig, indexUuid) => createEngineIndex(core, runnableConfig, name, indexConfig, indexUuid),
+    createIndex: (name, indexConfig) => createEngineIndex(core, runnableConfig, name, indexConfig, { adapterBinding: "deferred" }),
+    createIndexWithUuid: (name, indexConfig, indexUuid) => createEngineIndex(core, runnableConfig, name, indexConfig, { indexUuid }),
     acquireIndexForReplication: (indexName) => core.indexState.acquire(indexName, false),
     indexUuidOf: (indexName) => core.indexRegistry.get(indexName)?.indexUuid,
     stampIndexUuid: (indexName, indexUuid) => stampIndexUuid(core, indexName, indexUuid),
@@ -5209,7 +5235,7 @@ async function createClusterLocalEngine(config, hooks) {
     forgetHeldPartition: (indexName, partitionId) => heldPartitions.forget(indexName, partitionId),
     applyReplicationEntry: (entry) => applyLocalReplicationEntry(core, entry),
     serializeReplicationPartition: (indexName, partitionId) => serializeReplicationPartition(core, indexName, partitionId),
-    restoreReplicationPartition: (indexName, partitionId, bytes, schema, partitionCount) => restoreReplicationPartition(core, engine, indexName, partitionId, bytes, schema, partitionCount),
+    restoreReplicationPartition: (indexName, partitionId, bytes, indexConfig, partitionCount) => restoreReplicationPartition(core, engine, indexName, partitionId, bytes, indexConfig, partitionCount),
     queryPartitions: (indexName, params, partitionIds, globalStats) => runEngineQuery(core, indexName, params, { partitionIds, globalStats }),
     preflightPartitions: (indexName, params, partitionIds) => runEnginePreflight(core, indexName, params, { partitionIds }),
     suggestPartitions: (indexName, params, partitionIds) => runEngineSuggest(core, indexName, params, partitionIds),
@@ -5244,9 +5270,10 @@ async function serializeReplicationPartition(core, indexName, partitionId) {
     release();
   }
 }
-async function restoreReplicationPartition(core, engine, indexName, partitionId, bytes, schema, partitionCount) {
+async function restoreReplicationPartition(core, engine, indexName, partitionId, bytes, indexConfig, partitionCount) {
   core.guardShutdown();
   validatePartitionRestoreTarget(indexName, partitionId, partitionCount);
+  const schema = indexConfig.schema;
   let partition;
   try {
     partition = deserializePayloadV2(bytes);
@@ -5267,7 +5294,7 @@ async function restoreReplicationPartition(core, engine, indexName, partitionId,
       core,
       engine,
       indexName,
-      schema,
+      indexConfig,
       partition.language,
       partitionCount
     );
@@ -5359,16 +5386,15 @@ function validatePartitionSnapshotPayload(indexName, partitionId, partitionCount
     }
   }
 }
-async function ensureReplicationIndex(core, engine, indexName, schema, languageName, partitionCount) {
+async function ensureReplicationIndex(core, engine, indexName, coordinatorConfig, languageName, partitionCount) {
   const language = getLanguage(languageName);
   const existing = core.indexRegistry.get(indexName);
   let created = false;
   if (existing === void 0) {
-    const indexConfig = {
-      schema,
-      language: language.name,
-      partitions: { maxPartitions: partitionCount }
-    };
+    const indexConfig = withPartitionCount(
+      { ...coordinatorConfig, language: coordinatorConfig.language ?? language.name },
+      partitionCount
+    );
     try {
       await engine.createIndex(indexName, indexConfig);
       created = true;
@@ -5386,7 +5412,7 @@ async function ensureReplicationIndex(core, engine, indexName, schema, languageN
       receivedLanguage: language.name
     });
   }
-  validateExistingSchema(indexName, schema, entry.config.schema);
+  validateExistingSchema(indexName, coordinatorConfig.schema, entry.config.schema);
   const manager = core.requireManager(indexName);
   if (manager.partitionCount > partitionCount) {
     throw new NarsilError(ErrorCodes.SNAPSHOT_SYNC_RESTORE_FAILED, "local index has more partitions than allocation", {
@@ -6388,10 +6414,22 @@ function validateStringList(value, fieldLabel, errorCode) {
     validateBoundedString(value[i], `${fieldLabel}[${i}]`, errorCode);
   }
 }
+function validateRangeOperand(value, fieldLabel, errorCode) {
+  if (typeof value === "string") {
+    validateBoundedString(value, fieldLabel, errorCode);
+    return;
+  }
+  validateNumericOperand(value, fieldLabel, errorCode);
+}
 function validateBetween(value, fieldLabel, errorCode) {
   if (!Array.isArray(value) || value.length !== 2) {
     throwInvalid(errorCode, `Invalid payload: "${fieldLabel}" must be a two-element array`);
   }
+  if (typeof value[0] === "string" && typeof value[1] === "string") {
+    validateBoundedString(value[0], `${fieldLabel}[0]`, errorCode);
+    validateBoundedString(value[1], `${fieldLabel}[1]`, errorCode);
+    return;
+  }
   validateNumericOperand(value[0], `${fieldLabel}[0]`, errorCode);
   validateNumericOperand(value[1], `${fieldLabel}[1]`, errorCode);
 }
@@ -6455,7 +6493,7 @@ function validateGeoPolygon(value, fieldLabel, errorCode) {
 function validateLeafOperator(opKey, opValue, leafLabel, errorCode) {
   const opLabel = `${leafLabel}.${opKey}`;
   if (opKey === "gt" || opKey === "lt" || opKey === "gte" || opKey === "lte") {
-    validateNumericOperand(opValue, opLabel, errorCode);
+    validateRangeOperand(opValue, opLabel, errorCode);
     return;
   }
   if (opKey === "eq" || opKey === "ne") {
@@ -9228,8 +9266,9 @@ function validateCreateIndexOptions(partitionCount, replicationFactor) {
     );
   }
 }
-async function routeCreateIndex(name, config, options, coordinator, engine) {
+async function routeCreateIndex(name, requestedConfig, options, coordinator, engine) {
   validateIndexName(name);
+  const config = { ...requestedConfig, schema: validateSchema(requestedConfig.schema) };
   const partitionCount = options?.partitionCount ?? DEFAULT_PARTITION_COUNT;
   const replicationFactor = options?.replicationFactor ?? DEFAULT_REPLICATION_FACTOR;
   validateCreateIndexOptions(partitionCount, replicationFactor);
@@ -9243,7 +9282,8 @@ async function routeCreateIndex(name, config, options, coordinator, engine) {
     indexName: name,
     partitionCount,
     replicationFactor,
-    constraints
+    constraints,
+    settings: indexSettingsOf(config)
   };
   const stored = await putIndexMetadata(coordinator, metadata);
   if (!stored) {
@@ -9254,11 +9294,7 @@ async function routeCreateIndex(name, config, options, coordinator, engine) {
     );
   }
   try {
-    await engine.createIndexWithUuid(
-      name,
-      { ...config, partitions: { ...config.partitions, maxPartitions: partitionCount } },
-      metadata.indexUuid
-    );
+    await engine.createIndexWithUuid(name, withPartitionCount(config, partitionCount), metadata.indexUuid);
     await coordinator.putSchema(name, config.schema);
   } catch (createErr) {
     const cleanupError = await withdrawPartialIndex(name, coordinator, engine);
@@ -11236,8 +11272,15 @@ function createClusterOperationTracker(config) {
 
 // src/distribution/cluster-node/primary-partition.ts
 async function preparePrimaryPartition(indexName, partitionId, deps) {
-  const schema = await deps.coordinator.getSchema(indexName);
-  if (schema === null) {
+  const storedSchema = await deps.coordinator.getSchema(indexName);
+  if (storedSchema === null) {
+    return false;
+  }
+  let config;
+  try {
+    config = await getClusterIndexConfig(deps.coordinator, indexName, validateSchema(storedSchema));
+  } catch (error) {
+    deps.onError(error);
     return false;
   }
   const allocation = await deps.coordinator.getAllocation(indexName);
@@ -11247,10 +11290,7 @@ async function preparePrimaryPartition(indexName, partitionId, deps) {
   const existing = deps.engine.listIndexes().find((index) => index.name === indexName);
   if (existing === void 0) {
     try {
-      await deps.engine.createIndex(indexName, {
-        schema,
-        partitions: { maxPartitions: allocation.assignments.size }
-      });
+      await deps.engine.createIndex(indexName, withPartitionCount(config, allocation.assignments.size));
     } catch (error) {
       if (!(error instanceof NarsilError) || error.code !== ErrorCodes.INDEX_ALREADY_EXISTS) {
         deps.onError(error);
@@ -11258,7 +11298,7 @@ async function preparePrimaryPartition(indexName, partitionId, deps) {
       }
     }
   } else {
-    const schemaError = validateRestoredSchema(deps.engine, indexName, deps.nodeId, schema);
+    const schemaError = validateRestoredSchema(deps.engine, indexName, deps.nodeId, config.schema);
     if (schemaError !== null) {
       deps.onError(schemaError);
       return false;

package/dist/{engine-77ErLy8P.d.ts → engine-CXKfmK7I.d.ts}

@@ -1,6 +1,6 @@
 import { E as EmbeddingAdapter } from './adapters-79OIa4xm.js';
-import { B as BatchResult, I as IndexInfo, f as IndexStats, P as PartitionStatsResult, L as ListParams, g as ListResult, Q as QueryParams, e as QueryResult, h as PreflightResult, j as SuggestParams, k as SuggestResult, M as MemoryStats, V as VectorMaintenanceResult } from './memory-CKF-9WLP.js';
-import { A as AnyDocument, a as InsertOptions, W as WriteOptions, I as IndexConfig, P as PartitionConfig } from './schema-d5Afu03A.js';
+import { B as BatchResult, I as IndexInfo, f as IndexStats, P as PartitionStatsResult, L as ListParams, g as ListResult, Q as QueryParams, e as QueryResult, h as PreflightResult, j as SuggestParams, k as SuggestResult, M as MemoryStats, V as VectorMaintenanceResult } from './memory-C7UMCMH3.js';
+import { A as AnyDocument, a as InsertOptions, W as WriteOptions, I as IndexConfig, P as PartitionConfig } from './schema-Bgzr4g7b.js';
 
 /**
  * Every event the engine emits, with the payload each one carries.
@@ -58,16 +58,23 @@ type NarsilEventMap = {
         /** The index holds this many partitions now. */
         newCount: number;
     };
-    /** A partition passed its watermark, so the index is close to needing another one. */
+    /**
+     * An index passed its watermark, so its partitions are close to their
+     * capacity. On a cluster node, the engine reports the document count and the
+     * capacity of the one partition that `partitionId` names, which is a
+     * partition that this node leads.
+     */
     partitionWatermark: {
         /** This index crossed the mark. */
         indexName: string;
-        /** The index holds this many documents. */
+        /** The index holds this many documents, or the partition does on a cluster node. */
         documentCount: number;
-        /** The index can hold this many across its current partitions. */
+        /** The index can hold this many across its current partitions, or the partition can on a cluster node. */
         capacity: number;
         /** The index holds this many partitions. */
         partitionCount: number;
+        /** On a cluster node, this partition crossed the mark. The field is absent outside a cluster. */
+        partitionId?: number;
     };
     /**
      * The process uses nine tenths of its heap, measured during a write or a