@topgunbuild/core 0.10.1 → 0.12.0

package/dist/index.js

@@ -30,13 +30,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AuthAckMessageSchema: () => AuthAckMessageSchema,
   AuthFailMessageSchema: () => AuthFailMessageSchema,
   AuthMessageSchema: () => AuthMessageSchema,
+  AuthRequiredMessageSchema: () => AuthRequiredMessageSchema,
   BM25Scorer: () => BM25Scorer,
   BatchMessageSchema: () => BatchMessageSchema,
   BuiltInProcessors: () => BuiltInProcessors,
   BuiltInResolvers: () => BuiltInResolvers,
+  COST_WEIGHTS: () => COST_WEIGHTS,
   CRDTDebugger: () => CRDTDebugger,
+  CRDTInvariants: () => CRDTInvariants,
+  ChangeEventTypeSchema: () => ChangeEventTypeSchema,
   ClientOpMessageSchema: () => ClientOpMessageSchema,
   ClientOpSchema: () => ClientOpSchema,
   ClusterSearchReqMessageSchema: () => ClusterSearchReqMessageSchema,
@@ -78,6 +83,7 @@ __export(index_exports, {
   DEFAULT_RESOLVER_RATE_LIMITS: () => DEFAULT_RESOLVER_RATE_LIMITS,
   DEFAULT_STOP_WORDS: () => DEFAULT_STOP_WORDS,
   DEFAULT_WRITE_CONCERN_TIMEOUT: () => DEFAULT_WRITE_CONCERN_TIMEOUT,
+  DeltaRecordSchema: () => DeltaRecordSchema,
   ENGLISH_STOPWORDS: () => ENGLISH_STOPWORDS,
   EntryProcessBatchRequestSchema: () => EntryProcessBatchRequestSchema,
   EntryProcessBatchResponseSchema: () => EntryProcessBatchResponseSchema,
@@ -86,6 +92,7 @@ __export(index_exports, {
   EntryProcessResponseSchema: () => EntryProcessResponseSchema,
   EntryProcessorDefSchema: () => EntryProcessorDefSchema,
   EntryProcessorSchema: () => EntryProcessorSchema,
+  ErrorMessageSchema: () => ErrorMessageSchema,
   EventJournalImpl: () => EventJournalImpl,
   FORBIDDEN_PATTERNS: () => FORBIDDEN_PATTERNS,
   FTSInvertedIndex: () => BM25InvertedIndex,
@@ -97,12 +104,18 @@ __export(index_exports, {
   GcPrunePayloadSchema: () => GcPrunePayloadSchema,
   HLC: () => HLC,
   HashIndex: () => HashIndex,
-  HybridQueryDeltaPayloadSchema: () => HybridQueryDeltaPayloadSchema,
-  HybridQueryRespPayloadSchema: () => HybridQueryRespPayloadSchema,
+  HttpQueryRequestSchema: () => HttpQueryRequestSchema,
+  HttpQueryResultSchema: () => HttpQueryResultSchema,
+  HttpSearchRequestSchema: () => HttpSearchRequestSchema,
+  HttpSearchResultSchema: () => HttpSearchResultSchema,
+  HttpSyncErrorSchema: () => HttpSyncErrorSchema,
+  HttpSyncRequestSchema: () => HttpSyncRequestSchema,
+  HttpSyncResponseSchema: () => HttpSyncResponseSchema,
   IndexRegistry: () => IndexRegistry,
   IndexedLWWMap: () => IndexedLWWMap,
   IndexedORMap: () => IndexedORMap,
   IntersectionResultSet: () => IntersectionResultSet,
+  InvariantChecker: () => InvariantChecker,
   InvertedIndex: () => InvertedIndex,
   JournalEventDataSchema: () => JournalEventDataSchema,
   JournalEventMessageSchema: () => JournalEventMessageSchema,
@@ -118,11 +131,14 @@ __export(index_exports, {
   ListResolversRequestSchema: () => ListResolversRequestSchema,
   ListResolversResponseSchema: () => ListResolversResponseSchema,
   LiveQueryManager: () => LiveQueryManager,
+  LockGrantedMessageSchema: () => LockGrantedMessageSchema,
   LockGrantedPayloadSchema: () => LockGrantedPayloadSchema,
   LockReleaseSchema: () => LockReleaseSchema,
+  LockReleasedMessageSchema: () => LockReleasedMessageSchema,
   LockReleasedPayloadSchema: () => LockReleasedPayloadSchema,
   LockRequestSchema: () => LockRequestSchema,
   LowercaseFilter: () => LowercaseFilter,
+  MapDeltaSchema: () => MapDeltaSchema,
   MaxLengthFilter: () => MaxLengthFilter,
   MergeRejectedMessageSchema: () => MergeRejectedMessageSchema,
   MerkleReqBucketMessageSchema: () => MerkleReqBucketMessageSchema,
@@ -132,9 +148,11 @@ __export(index_exports, {
   MultiValueAttribute: () => MultiValueAttribute,
   NGramTokenizer: () => NGramTokenizer,
   NavigableIndex: () => NavigableIndex,
+  NodeInfoSchema: () => NodeInfoSchema,
   ORMap: () => ORMap,
   ORMapDiffRequestSchema: () => ORMapDiffRequestSchema,
   ORMapDiffResponseSchema: () => ORMapDiffResponseSchema,
+  ORMapEntrySchema: () => ORMapEntrySchema,
   ORMapMerkleReqBucketSchema: () => ORMapMerkleReqBucketSchema,
   ORMapMerkleTree: () => ORMapMerkleTree,
   ORMapPushDiffSchema: () => ORMapPushDiffSchema,
@@ -150,6 +168,9 @@ __export(index_exports, {
   PARTITION_COUNT: () => PARTITION_COUNT,
   PNCounterImpl: () => PNCounterImpl,
   PNCounterStateObjectSchema: () => PNCounterStateObjectSchema,
+  PartitionInfoSchema: () => PartitionInfoSchema,
+  PartitionMapMessageSchema: () => PartitionMapMessageSchema,
+  PartitionMapPayloadSchema: () => PartitionMapPayloadSchema,
   PartitionMapRequestSchema: () => PartitionMapRequestSchema,
   PartitionState: () => PartitionState,
   PingMessageSchema: () => PingMessageSchema,
@@ -167,10 +188,12 @@ __export(index_exports, {
   QueryUpdateMessageSchema: () => QueryUpdateMessageSchema,
   QueryUpdatePayloadSchema: () => QueryUpdatePayloadSchema,
   RESOLVER_FORBIDDEN_PATTERNS: () => RESOLVER_FORBIDDEN_PATTERNS,
+  RealClock: () => RealClock,
   ReciprocalRankFusion: () => ReciprocalRankFusion,
   RegisterResolverRequestSchema: () => RegisterResolverRequestSchema,
   RegisterResolverResponseSchema: () => RegisterResolverResponseSchema,
   Ringbuffer: () => Ringbuffer,
+  ScenarioRunner: () => ScenarioRunner,
   SearchCursor: () => SearchCursor,
   SearchDebugger: () => SearchDebugger,
   SearchMessageSchema: () => SearchMessageSchema,
@@ -185,6 +208,7 @@ __export(index_exports, {
   SearchUpdateMessageSchema: () => SearchUpdateMessageSchema,
   SearchUpdatePayloadSchema: () => SearchUpdatePayloadSchema,
   SearchUpdateTypeSchema: () => SearchUpdateTypeSchema,
+  SeededRNG: () => SeededRNG,
   ServerBatchEventMessageSchema: () => ServerBatchEventMessageSchema,
   ServerEventMessageSchema: () => ServerEventMessageSchema,
   ServerEventPayloadSchema: () => ServerEventPayloadSchema,
@@ -196,6 +220,8 @@ __export(index_exports, {
   StandingQueryRegistry: () => StandingQueryRegistry,
   StopWordFilter: () => StopWordFilter,
   SyncInitMessageSchema: () => SyncInitMessageSchema,
+  SyncMapEntrySchema: () => SyncMapEntrySchema,
+  SyncResetRequiredMessageSchema: () => SyncResetRequiredMessageSchema,
   SyncResetRequiredPayloadSchema: () => SyncResetRequiredPayloadSchema,
   SyncRespBucketsMessageSchema: () => SyncRespBucketsMessageSchema,
   SyncRespLeafMessageSchema: () => SyncRespLeafMessageSchema,
@@ -211,11 +237,14 @@ __export(index_exports, {
   UniqueFilter: () => UniqueFilter,
   UnregisterResolverRequestSchema: () => UnregisterResolverRequestSchema,
   UnregisterResolverResponseSchema: () => UnregisterResolverResponseSchema,
+  VirtualClock: () => VirtualClock,
+  VirtualNetwork: () => VirtualNetwork,
   WRITE_CONCERN_ORDER: () => WRITE_CONCERN_ORDER,
   WhitespaceTokenizer: () => WhitespaceTokenizer,
   WordBoundaryTokenizer: () => WordBoundaryTokenizer,
   WriteConcern: () => WriteConcern,
   WriteConcernSchema: () => WriteConcernSchema,
+  calculateTotalCost: () => calculateTotalCost,
   combineHashes: () => combineHashes,
   compareHLCTimestamps: () => compareHLCTimestamps,
   compareTimestamps: () => compareTimestamps,
@@ -225,7 +254,6 @@ __export(index_exports, {
   decodeBase64Url: () => decodeBase64Url,
   deepMerge: () => deepMerge,
   deserialize: () => deserialize,
-  disableNativeHash: () => disableNativeHash,
   encodeBase64Url: () => encodeBase64Url,
   evaluatePredicate: () => evaluatePredicate,
   getCRDTDebugger: () => getCRDTDebugger,
@@ -237,13 +265,11 @@ __export(index_exports, {
   hashString: () => hashString,
   isLogicalQuery: () => isLogicalQuery,
   isSimpleQuery: () => isSimpleQuery,
-  isUsingNativeHash: () => isUsingNativeHash,
   isWriteConcernAchieved: () => isWriteConcernAchieved,
   logger: () => logger,
   multiAttribute: () => multiAttribute,
   porterStem: () => porterStem,
   resetCRDTDebugger: () => resetCRDTDebugger,
-  resetNativeHash: () => resetNativeHash,
   resetSearchDebugger: () => resetSearchDebugger,
   serialize: () => serialize,
   simpleAttribute: () => simpleAttribute,
@@ -266,9 +292,13 @@ var logger = (0, import_pino.default)({
 // src/HLC.ts
 var HLC = class {
   constructor(nodeId, options = {}) {
+    if (nodeId.includes(":")) {
+      throw new Error('Node ID must not contain ":" (used as delimiter in timestamp format)');
+    }
     this.nodeId = nodeId;
     this.strictMode = options.strictMode ?? false;
     this.maxDriftMs = options.maxDriftMs ?? 6e4;
+    this.clockSource = options.clockSource ?? { now: () => Date.now() };
     this.lastMillis = 0;
     this.lastCounter = 0;
   }
@@ -281,12 +311,19 @@ var HLC = class {
   get getMaxDriftMs() {
     return this.maxDriftMs;
   }
+  /**
+   * Returns the clock source used by this HLC instance.
+   * Useful for LWWMap/ORMap to access the same clock for TTL checks.
+   */
+  getClockSource() {
+    return this.clockSource;
+  }
   /**
    * Generates a new unique timestamp for a local event.
    * Ensures monotonicity: always greater than any previously generated or received timestamp.
    */
   now() {
-    const systemTime = Date.now();
+    const systemTime = this.clockSource.now();
     if (systemTime > this.lastMillis) {
       this.lastMillis = systemTime;
       this.lastCounter = 0;
@@ -304,27 +341,33 @@ var HLC = class {
    * Must be called whenever a message/event is received from another node.
    */
   update(remote) {
-    const systemTime = Date.now();
-    const drift = remote.millis - systemTime;
+    const remoteMillis = Number(remote.millis);
+    const remoteCounter = Number(remote.counter);
+    if (!Number.isFinite(remoteMillis) || !Number.isFinite(remoteCounter)) {
+      logger.warn({ remoteMillis, remoteCounter, remote }, "HLC.update() received invalid timestamp, ignoring");
+      return;
+    }
+    const systemTime = this.clockSource.now();
+    const drift = remoteMillis - systemTime;
     if (drift > this.maxDriftMs) {
       if (this.strictMode) {
-        throw new Error(`Clock drift detected: Remote time ${remote.millis} is ${drift}ms ahead of local ${systemTime} (threshold: ${this.maxDriftMs}ms)`);
+        throw new Error(`Clock drift detected: Remote time ${remoteMillis} is ${drift}ms ahead of local ${systemTime} (threshold: ${this.maxDriftMs}ms)`);
       } else {
         logger.warn({
           drift,
-          remoteMillis: remote.millis,
+          remoteMillis,
           localMillis: systemTime,
           maxDriftMs: this.maxDriftMs
         }, "Clock drift detected");
       }
     }
-    const maxMillis = Math.max(this.lastMillis, systemTime, remote.millis);
-    if (maxMillis === this.lastMillis && maxMillis === remote.millis) {
-      this.lastCounter = Math.max(this.lastCounter, remote.counter) + 1;
+    const maxMillis = Math.max(this.lastMillis, systemTime, remoteMillis);
+    if (maxMillis === this.lastMillis && maxMillis === remoteMillis) {
+      this.lastCounter = Math.max(this.lastCounter, remoteCounter) + 1;
     } else if (maxMillis === this.lastMillis) {
       this.lastCounter++;
-    } else if (maxMillis === remote.millis) {
-      this.lastCounter = remote.counter + 1;
+    } else if (maxMillis === remoteMillis) {
+      this.lastCounter = remoteCounter + 1;
     } else {
       this.lastCounter = 0;
     }
@@ -367,17 +410,7 @@ var HLC = class {
 };
 
 // src/utils/hash.ts
-var nativeHash = null;
-var nativeLoadAttempted = false;
-function tryLoadNative() {
-  if (nativeLoadAttempted) return;
-  nativeLoadAttempted = true;
-  try {
-    nativeHash = require("@topgunbuild/native");
-  } catch {
-  }
-}
-function fnv1aHash(str) {
+function hashString(str) {
   let hash = 2166136261;
   for (let i = 0; i < str.length; i++) {
     hash ^= str.charCodeAt(i);
@@ -385,13 +418,6 @@ function fnv1aHash(str) {
   }
   return hash >>> 0;
 }
-function hashString(str) {
-  tryLoadNative();
-  if (nativeHash && nativeHash.isNativeHashAvailable()) {
-    return nativeHash.hashString(str);
-  }
-  return fnv1aHash(str);
-}
 function combineHashes(hashes) {
   let result = 0;
   for (const h of hashes) {
@@ -399,18 +425,6 @@ function combineHashes(hashes) {
   }
   return result >>> 0;
 }
-function isUsingNativeHash() {
-  tryLoadNative();
-  return nativeHash?.isNativeHashAvailable() === true;
-}
-function disableNativeHash() {
-  nativeHash = null;
-  nativeLoadAttempted = true;
-}
-function resetNativeHash() {
-  nativeHash = null;
-  nativeLoadAttempted = false;
-}
 function hashObject(obj) {
   const json = JSON.stringify(obj, (_, value) => {
     if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -588,7 +602,7 @@ var LWWMap = class {
       return void 0;
     }
     if (record.ttlMs) {
-      const now = Date.now();
+      const now = this.hlc.getClockSource().now();
       if (record.timestamp.millis + record.ttlMs < now) {
         return void 0;
       }
@@ -665,7 +679,7 @@ var LWWMap = class {
    */
   entries() {
     const iterator = this.data.entries();
-    const now = Date.now();
+    const clockSource = this.hlc.getClockSource();
     return {
       [Symbol.iterator]() {
         return this;
@@ -675,7 +689,7 @@ var LWWMap = class {
         while (!result.done) {
           const [key, record] = result.value;
           if (record.value !== null) {
-            if (record.ttlMs && record.timestamp.millis + record.ttlMs < now) {
+            if (record.ttlMs && record.timestamp.millis + record.ttlMs < clockSource.now()) {
               result = iterator.next();
               continue;
             }
@@ -1012,7 +1026,7 @@ var ORMap = class {
     const keyMap = this.items.get(key);
     if (!keyMap) return [];
     const values = [];
-    const now = Date.now();
+    const now = this.hlc.getClockSource().now();
     for (const [tag, record] of keyMap.entries()) {
       if (!this.tombstones.has(tag)) {
         if (record.ttlMs && record.timestamp.millis + record.ttlMs < now) {
@@ -1032,7 +1046,7 @@ var ORMap = class {
     const keyMap = this.items.get(key);
     if (!keyMap) return [];
     const records = [];
-    const now = Date.now();
+    const now = this.hlc.getClockSource().now();
     for (const [tag, record] of keyMap.entries()) {
       if (!this.tombstones.has(tag)) {
         if (record.ttlMs && record.timestamp.millis + record.ttlMs < now) {
@@ -1248,11 +1262,49 @@ var ORMap = class {
 // src/serializer.ts
 var import_msgpackr = require("msgpackr");
 function serialize(data) {
-  return (0, import_msgpackr.pack)(data);
+  return (0, import_msgpackr.pack)(stripUndefined(data));
 }
 function deserialize(data) {
   const buffer = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
-  return (0, import_msgpackr.unpack)(buffer);
+  const result = (0, import_msgpackr.unpack)(buffer);
+  return coerceBigInts(result);
+}
+function stripUndefined(value) {
+  if (value === void 0) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return value.map(stripUndefined);
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v !== void 0) {
+        result[k] = stripUndefined(v);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+function coerceBigInts(value) {
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      value[i] = coerceBigInts(value[i]);
+    }
+    return value;
+  }
+  if (value !== null && typeof value === "object") {
+    const obj = value;
+    for (const key of Object.keys(obj)) {
+      obj[key] = coerceBigInts(obj[key]);
+    }
+    return obj;
+  }
+  return value;
 }
 
 // src/PNCounter.ts
@@ -2427,6 +2479,7 @@ var ORMapRecordSchema = import_zod3.z.object({
   tag: import_zod3.z.string(),
   ttlMs: import_zod3.z.number().optional()
 });
+var ChangeEventTypeSchema = import_zod3.z.enum(["ENTER", "UPDATE", "LEAVE"]);
 var PredicateOpSchema = import_zod3.z.enum([
   "eq",
   "neq",
@@ -2467,7 +2520,11 @@ var ClientOpSchema = import_zod3.z.object({
 });
 var AuthMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("AUTH"),
-  token: import_zod3.z.string()
+  token: import_zod3.z.string(),
+  protocolVersion: import_zod3.z.number().optional()
+});
+var AuthRequiredMessageSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("AUTH_REQUIRED")
 });
 
 // src/schemas/sync-schemas.ts
@@ -2523,6 +2580,11 @@ var MerkleReqBucketMessageSchema = import_zod4.z.object({
     path: import_zod4.z.string()
   })
 });
+var ORMapEntrySchema = import_zod4.z.object({
+  key: import_zod4.z.string(),
+  records: import_zod4.z.array(ORMapRecordSchema),
+  tombstones: import_zod4.z.array(import_zod4.z.string())
+});
 var ORMapSyncInitSchema = import_zod4.z.object({
   type: import_zod4.z.literal("ORMAP_SYNC_INIT"),
   mapName: import_zod4.z.string(),
@@ -2558,11 +2620,7 @@ var ORMapSyncRespLeafSchema = import_zod4.z.object({
   payload: import_zod4.z.object({
     mapName: import_zod4.z.string(),
     path: import_zod4.z.string(),
-    entries: import_zod4.z.array(import_zod4.z.object({
-      key: import_zod4.z.string(),
-      records: import_zod4.z.array(ORMapRecordSchema),
-      tombstones: import_zod4.z.array(import_zod4.z.string())
-    }))
+    entries: import_zod4.z.array(ORMapEntrySchema)
   })
 });
 var ORMapDiffRequestSchema = import_zod4.z.object({
@@ -2576,22 +2634,14 @@ var ORMapDiffResponseSchema = import_zod4.z.object({
   type: import_zod4.z.literal("ORMAP_DIFF_RESPONSE"),
   payload: import_zod4.z.object({
     mapName: import_zod4.z.string(),
-    entries: import_zod4.z.array(import_zod4.z.object({
-      key: import_zod4.z.string(),
-      records: import_zod4.z.array(ORMapRecordSchema),
-      tombstones: import_zod4.z.array(import_zod4.z.string())
-    }))
+    entries: import_zod4.z.array(ORMapEntrySchema)
   })
 });
 var ORMapPushDiffSchema = import_zod4.z.object({
   type: import_zod4.z.literal("ORMAP_PUSH_DIFF"),
   payload: import_zod4.z.object({
     mapName: import_zod4.z.string(),
-    entries: import_zod4.z.array(import_zod4.z.object({
-      key: import_zod4.z.string(),
-      records: import_zod4.z.array(ORMapRecordSchema),
-      tombstones: import_zod4.z.array(import_zod4.z.string())
-    }))
+    entries: import_zod4.z.array(ORMapEntrySchema)
   })
 });
 var OpResultSchema = import_zod4.z.object({
@@ -2686,7 +2736,7 @@ var SearchRespMessageSchema = import_zod6.z.object({
   type: import_zod6.z.literal("SEARCH_RESP"),
   payload: SearchRespPayloadSchema
 });
-var SearchUpdateTypeSchema = import_zod6.z.enum(["ENTER", "UPDATE", "LEAVE"]);
+var SearchUpdateTypeSchema = ChangeEventTypeSchema;
 var SearchSubPayloadSchema = import_zod6.z.object({
   subscriptionId: import_zod6.z.string(),
   mapName: import_zod6.z.string(),
@@ -2703,7 +2753,7 @@ var SearchUpdatePayloadSchema = import_zod6.z.object({
   value: import_zod6.z.unknown(),
   score: import_zod6.z.number(),
   matchedTerms: import_zod6.z.array(import_zod6.z.string()),
-  type: SearchUpdateTypeSchema
+  changeType: SearchUpdateTypeSchema
 });
 var SearchUpdateMessageSchema = import_zod6.z.object({
   type: import_zod6.z.literal("SEARCH_UPDATE"),
@@ -2725,17 +2775,37 @@ var PartitionMapRequestSchema = import_zod7.z.object({
     currentVersion: import_zod7.z.number().optional()
   }).optional()
 });
+var NodeInfoSchema = import_zod7.z.object({
+  nodeId: import_zod7.z.string(),
+  endpoints: import_zod7.z.object({
+    websocket: import_zod7.z.string(),
+    http: import_zod7.z.string().optional()
+  }),
+  status: import_zod7.z.enum(["ACTIVE", "JOINING", "LEAVING", "SUSPECTED", "FAILED"])
+});
+var PartitionInfoSchema = import_zod7.z.object({
+  partitionId: import_zod7.z.number(),
+  ownerNodeId: import_zod7.z.string(),
+  backupNodeIds: import_zod7.z.array(import_zod7.z.string())
+});
+var PartitionMapPayloadSchema = import_zod7.z.object({
+  version: import_zod7.z.number(),
+  partitionCount: import_zod7.z.number(),
+  nodes: import_zod7.z.array(NodeInfoSchema),
+  partitions: import_zod7.z.array(PartitionInfoSchema),
+  generatedAt: import_zod7.z.number()
+});
+var PartitionMapMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("PARTITION_MAP"),
+  payload: PartitionMapPayloadSchema
+});
 var ClusterSubRegisterPayloadSchema = import_zod7.z.object({
   subscriptionId: import_zod7.z.string(),
   coordinatorNodeId: import_zod7.z.string(),
   mapName: import_zod7.z.string(),
   type: import_zod7.z.enum(["SEARCH", "QUERY"]),
   searchQuery: import_zod7.z.string().optional(),
-  searchOptions: import_zod7.z.object({
-    limit: import_zod7.z.number().int().positive().optional(),
-    minScore: import_zod7.z.number().optional(),
-    boost: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.number()).optional()
-  }).optional(),
+  searchOptions: SearchOptionsSchema.optional(),
   queryPredicate: import_zod7.z.any().optional(),
   querySort: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.enum(["asc", "desc"])).optional()
 });
@@ -2767,7 +2837,7 @@ var ClusterSubUpdatePayloadSchema = import_zod7.z.object({
   value: import_zod7.z.unknown(),
   score: import_zod7.z.number().optional(),
   matchedTerms: import_zod7.z.array(import_zod7.z.string()).optional(),
-  changeType: import_zod7.z.enum(["ENTER", "UPDATE", "LEAVE"]),
+  changeType: ChangeEventTypeSchema,
   timestamp: import_zod7.z.number()
 });
 var ClusterSubUpdateMessageSchema = import_zod7.z.object({
@@ -2785,10 +2855,8 @@ var ClusterSearchReqPayloadSchema = import_zod7.z.object({
   requestId: import_zod7.z.string(),
   mapName: import_zod7.z.string(),
   query: import_zod7.z.string(),
-  options: import_zod7.z.object({
+  options: SearchOptionsSchema.extend({
     limit: import_zod7.z.number().int().positive().max(1e3),
-    minScore: import_zod7.z.number().optional(),
-    boost: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.number()).optional(),
     includeMatchedTerms: import_zod7.z.boolean().optional(),
     afterScore: import_zod7.z.number().optional(),
     afterKey: import_zod7.z.string().optional()
@@ -2840,7 +2908,7 @@ var ClusterSearchUpdatePayloadSchema = import_zod7.z.object({
   value: import_zod7.z.unknown(),
   score: import_zod7.z.number(),
   matchedTerms: import_zod7.z.array(import_zod7.z.string()).optional(),
-  type: SearchUpdateTypeSchema
+  changeType: ChangeEventTypeSchema
 });
 var ClusterSearchUpdateMessageSchema = import_zod7.z.object({
   type: import_zod7.z.literal("CLUSTER_SEARCH_UPDATE"),
@@ -3083,7 +3151,7 @@ var QueryUpdatePayloadSchema = import_zod9.z.object({
   queryId: import_zod9.z.string(),
   key: import_zod9.z.string(),
   value: import_zod9.z.unknown(),
-  type: import_zod9.z.enum(["ENTER", "UPDATE", "REMOVE"])
+  changeType: ChangeEventTypeSchema
 });
 var QueryUpdateMessageSchema = import_zod9.z.object({
   type: import_zod9.z.literal("QUERY_UPDATE"),
@@ -3096,50 +3164,135 @@ var GcPruneMessageSchema = import_zod9.z.object({
   type: import_zod9.z.literal("GC_PRUNE"),
   payload: GcPrunePayloadSchema
 });
+var AuthAckMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("AUTH_ACK"),
+  protocolVersion: import_zod9.z.number().optional(),
+  userId: import_zod9.z.string().optional()
+});
 var AuthFailMessageSchema = import_zod9.z.object({
   type: import_zod9.z.literal("AUTH_FAIL"),
   error: import_zod9.z.string().optional(),
   code: import_zod9.z.number().optional()
 });
-var HybridQueryRespPayloadSchema = import_zod9.z.object({
-  subscriptionId: import_zod9.z.string(),
-  results: import_zod9.z.array(import_zod9.z.object({
-    key: import_zod9.z.string(),
-    value: import_zod9.z.unknown(),
-    score: import_zod9.z.number(),
-    matchedTerms: import_zod9.z.array(import_zod9.z.string())
-  })),
-  nextCursor: import_zod9.z.string().optional(),
-  hasMore: import_zod9.z.boolean().optional(),
-  cursorStatus: CursorStatusSchema.optional()
-});
-var HybridQueryDeltaPayloadSchema = import_zod9.z.object({
-  subscriptionId: import_zod9.z.string(),
-  key: import_zod9.z.string(),
-  value: import_zod9.z.unknown().nullable(),
-  score: import_zod9.z.number().optional(),
-  matchedTerms: import_zod9.z.array(import_zod9.z.string()).optional(),
-  type: import_zod9.z.enum(["ENTER", "UPDATE", "LEAVE"])
+var ErrorMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("ERROR"),
+  payload: import_zod9.z.object({
+    code: import_zod9.z.number(),
+    message: import_zod9.z.string(),
+    details: import_zod9.z.unknown().optional()
+  })
 });
 var LockGrantedPayloadSchema = import_zod9.z.object({
   requestId: import_zod9.z.string(),
+  name: import_zod9.z.string(),
   fencingToken: import_zod9.z.number()
 });
 var LockReleasedPayloadSchema = import_zod9.z.object({
   requestId: import_zod9.z.string(),
+  name: import_zod9.z.string(),
   success: import_zod9.z.boolean()
 });
+var LockGrantedMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("LOCK_GRANTED"),
+  payload: LockGrantedPayloadSchema
+});
+var LockReleasedMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("LOCK_RELEASED"),
+  payload: LockReleasedPayloadSchema
+});
 var SyncResetRequiredPayloadSchema = import_zod9.z.object({
   mapName: import_zod9.z.string(),
   reason: import_zod9.z.string()
 });
+var SyncResetRequiredMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("SYNC_RESET_REQUIRED"),
+  payload: SyncResetRequiredPayloadSchema
+});
 
-// src/schemas/index.ts
+// src/schemas/http-sync-schemas.ts
 var import_zod10 = require("zod");
-var MessageSchema = import_zod10.z.discriminatedUnion("type", [
+var SyncMapEntrySchema = import_zod10.z.object({
+  mapName: import_zod10.z.string(),
+  lastSyncTimestamp: TimestampSchema
+});
+var HttpQueryRequestSchema = import_zod10.z.object({
+  queryId: import_zod10.z.string(),
+  mapName: import_zod10.z.string(),
+  filter: import_zod10.z.any(),
+  limit: import_zod10.z.number().optional(),
+  offset: import_zod10.z.number().optional()
+});
+var HttpSearchRequestSchema = import_zod10.z.object({
+  searchId: import_zod10.z.string(),
+  mapName: import_zod10.z.string(),
+  query: import_zod10.z.string(),
+  options: import_zod10.z.any().optional()
+});
+var HttpSyncRequestSchema = import_zod10.z.object({
+  // Client identification
+  clientId: import_zod10.z.string(),
+  // Client's current HLC for causality tracking
+  clientHlc: TimestampSchema,
+  // Batch of operations to push (optional)
+  operations: import_zod10.z.array(ClientOpSchema).optional(),
+  // Maps the client wants deltas for, with their last known sync HLC timestamp
+  syncMaps: import_zod10.z.array(SyncMapEntrySchema).optional(),
+  // One-shot queries to execute (optional)
+  queries: import_zod10.z.array(HttpQueryRequestSchema).optional(),
+  // One-shot search requests (optional)
+  searches: import_zod10.z.array(HttpSearchRequestSchema).optional()
+});
+var DeltaRecordSchema = import_zod10.z.object({
+  key: import_zod10.z.string(),
+  record: LWWRecordSchema,
+  eventType: import_zod10.z.enum(["PUT", "REMOVE"])
+});
+var MapDeltaSchema = import_zod10.z.object({
+  mapName: import_zod10.z.string(),
+  records: import_zod10.z.array(DeltaRecordSchema),
+  serverSyncTimestamp: TimestampSchema
+});
+var HttpQueryResultSchema = import_zod10.z.object({
+  queryId: import_zod10.z.string(),
+  results: import_zod10.z.array(import_zod10.z.any()),
+  hasMore: import_zod10.z.boolean().optional(),
+  nextCursor: import_zod10.z.string().optional()
+});
+var HttpSearchResultSchema = import_zod10.z.object({
+  searchId: import_zod10.z.string(),
+  results: import_zod10.z.array(import_zod10.z.any()),
+  totalCount: import_zod10.z.number().optional()
+});
+var HttpSyncErrorSchema = import_zod10.z.object({
+  code: import_zod10.z.number(),
+  message: import_zod10.z.string(),
+  context: import_zod10.z.string().optional()
+});
+var HttpSyncResponseSchema = import_zod10.z.object({
+  // Server's current HLC
+  serverHlc: TimestampSchema,
+  // Acknowledgment of received operations
+  ack: import_zod10.z.object({
+    lastId: import_zod10.z.string(),
+    results: import_zod10.z.array(OpResultSchema).optional()
+  }).optional(),
+  // Delta records for requested maps (new/changed since lastSyncTimestamp)
+  deltas: import_zod10.z.array(MapDeltaSchema).optional(),
+  // Query results
+  queryResults: import_zod10.z.array(HttpQueryResultSchema).optional(),
+  // Search results
+  searchResults: import_zod10.z.array(HttpSearchResultSchema).optional(),
+  // Errors for individual operations
+  errors: import_zod10.z.array(HttpSyncErrorSchema).optional()
+});
+
+// src/schemas/index.ts
+var import_zod11 = require("zod");
+var MessageSchema = import_zod11.z.discriminatedUnion("type", [
+  // --- Base ---
   AuthMessageSchema,
-  QuerySubMessageSchema,
-  QueryUnsubMessageSchema,
+  AuthRequiredMessageSchema,
+  // --- Sync ---
   ClientOpMessageSchema,
   OpBatchMessageSchema,
   SyncInitMessageSchema,
@@ -3147,13 +3300,10 @@ var MessageSchema = import_zod10.z.discriminatedUnion("type", [
   SyncRespBucketsMessageSchema,
   SyncRespLeafMessageSchema,
   MerkleReqBucketMessageSchema,
-  LockRequestSchema,
-  LockReleaseSchema,
-  TopicSubSchema,
-  TopicUnsubSchema,
-  TopicPubSchema,
-  PingMessageSchema,
-  PongMessageSchema,
+  OpAckMessageSchema,
+  OpRejectedMessageSchema,
+  BatchMessageSchema,
+  // --- ORMap Sync ---
   ORMapSyncInitSchema,
   ORMapSyncRespRootSchema,
   ORMapSyncRespBucketsSchema,
@@ -3162,18 +3312,54 @@ var MessageSchema = import_zod10.z.discriminatedUnion("type", [
   ORMapDiffRequestSchema,
   ORMapDiffResponseSchema,
   ORMapPushDiffSchema,
+  // --- Query ---
+  QuerySubMessageSchema,
+  QueryUnsubMessageSchema,
+  QueryRespMessageSchema,
+  QueryUpdateMessageSchema,
+  // --- Search ---
+  SearchMessageSchema,
+  SearchRespMessageSchema,
+  SearchSubMessageSchema,
+  SearchUpdateMessageSchema,
+  SearchUnsubMessageSchema,
+  // --- Cluster ---
   PartitionMapRequestSchema,
+  PartitionMapMessageSchema,
+  ClusterSubRegisterMessageSchema,
+  ClusterSubAckMessageSchema,
+  ClusterSubUpdateMessageSchema,
+  ClusterSubUnregisterMessageSchema,
+  ClusterSearchReqMessageSchema,
+  ClusterSearchRespMessageSchema,
+  ClusterSearchSubscribeMessageSchema,
+  ClusterSearchUnsubscribeMessageSchema,
+  ClusterSearchUpdateMessageSchema,
+  // --- Messaging ---
+  TopicSubSchema,
+  TopicUnsubSchema,
+  TopicPubSchema,
+  TopicMessageEventSchema,
+  LockRequestSchema,
+  LockReleaseSchema,
   CounterRequestSchema,
   CounterSyncSchema,
+  CounterResponseSchema,
+  CounterUpdateSchema,
+  PingMessageSchema,
+  PongMessageSchema,
+  // --- Entry Processor ---
   EntryProcessRequestSchema,
   EntryProcessBatchRequestSchema,
   EntryProcessResponseSchema,
   EntryProcessBatchResponseSchema,
+  // --- Journal ---
   JournalSubscribeRequestSchema,
   JournalUnsubscribeRequestSchema,
   JournalEventMessageSchema,
   JournalReadRequestSchema,
   JournalReadResponseSchema,
+  // --- Conflict Resolver ---
   RegisterResolverRequestSchema,
   RegisterResolverResponseSchema,
   UnregisterResolverRequestSchema,
@@ -3181,15 +3367,16 @@ var MessageSchema = import_zod10.z.discriminatedUnion("type", [
   MergeRejectedMessageSchema,
   ListResolversRequestSchema,
   ListResolversResponseSchema,
-  SearchMessageSchema,
-  SearchRespMessageSchema,
-  SearchSubMessageSchema,
-  SearchUpdateMessageSchema,
-  SearchUnsubMessageSchema,
-  ClusterSubRegisterMessageSchema,
-  ClusterSubAckMessageSchema,
-  ClusterSubUpdateMessageSchema,
-  ClusterSubUnregisterMessageSchema
+  // --- Server-to-Client ---
+  ServerEventMessageSchema,
+  ServerBatchEventMessageSchema,
+  GcPruneMessageSchema,
+  AuthAckMessageSchema,
+  AuthFailMessageSchema,
+  ErrorMessageSchema,
+  LockGrantedMessageSchema,
+  LockReleasedMessageSchema,
+  SyncResetRequiredMessageSchema
 ]);
 
 // src/types/WriteConcern.ts
@@ -4149,6 +4336,18 @@ function createPredicateMatcher(getAttribute) {
 }
 
 // src/query/QueryTypes.ts
+var COST_WEIGHTS = {
+  CPU: 1,
+  NETWORK: 10,
+  // Network is expensive (latency, bandwidth)
+  IO: 5,
+  // Disk I/O is moderately expensive
+  ROWS: 1e-3
+  // Row count factor
+};
+function calculateTotalCost(cost) {
+  return cost.rows * COST_WEIGHTS.ROWS + cost.cpu * COST_WEIGHTS.CPU + cost.network * COST_WEIGHTS.NETWORK + cost.io * COST_WEIGHTS.IO;
+}
 function isSimpleQuery(query) {
   return [
     "eq",
@@ -6470,13 +6669,22 @@ var QueryOptimizer = class {
    * Optimize a query and return an execution plan.
    *
    * Optimization order (by cost):
-   * 1. StandingQueryIndex (cost: 10) - pre-computed results
-   * 2. Other indexes via optimizeNode
+   * 1. Point lookup (cost: 1) - direct primary key access
+   * 2. StandingQueryIndex (cost: 10) - pre-computed results
+   * 3. Other indexes via optimizeNode
    *
    * @param query - Query to optimize
    * @returns Query execution plan
    */
   optimize(query) {
+    const pointLookupStep = this.tryPointLookup(query);
+    if (pointLookupStep) {
+      return {
+        root: pointLookupStep,
+        estimatedCost: this.estimateCost(pointLookupStep),
+        usesIndexes: this.usesIndexes(pointLookupStep)
+      };
+    }
     if (this.standingQueryRegistry) {
       const standingIndex = this.standingQueryRegistry.getIndex(query);
       if (standingIndex) {
@@ -6500,16 +6708,68 @@ var QueryOptimizer = class {
     };
   }
   /**
-   * Optimize a query with sort/limit/offset options.
+   * Optimize a query with sort/limit/offset options and index hints.
+   *
+   * Hint precedence: disableOptimization > useIndex > forceIndexScan.
    *
    * @param query - Query to optimize
-   * @param options - Query options (sort, limit, offset)
+   * @param options - Query options (sort, limit, cursor, hints)
    * @returns Query execution plan with options
    */
   optimizeWithOptions(query, options) {
+    if (options.disableOptimization) {
+      return {
+        root: { type: "full-scan", predicate: query },
+        estimatedCost: Number.MAX_SAFE_INTEGER,
+        usesIndexes: false
+      };
+    }
+    if (options.useIndex) {
+      const indexes = this.indexRegistry.getIndexes(options.useIndex);
+      if (indexes.length === 0) {
+        throw new Error(
+          `Index hint: no index found for attribute "${options.useIndex}"`
+        );
+      }
+      let best = indexes[0];
+      for (let i = 1; i < indexes.length; i++) {
+        if (indexes[i].getRetrievalCost() < best.getRetrievalCost()) {
+          best = indexes[i];
+        }
+      }
+      const step = {
+        type: "index-scan",
+        index: best,
+        query: this.buildHintedIndexQuery(query, options.useIndex)
+      };
+      return this.applyPlanOptions(
+        {
+          root: step,
+          estimatedCost: best.getRetrievalCost(),
+          usesIndexes: true,
+          hint: options.useIndex
+        },
+        options
+      );
+    }
     const basePlan = this.optimize(query);
+    if (options.forceIndexScan && !basePlan.usesIndexes) {
+      throw new Error(
+        "No suitable index found and forceIndexScan is enabled"
+      );
+    }
+    return this.applyPlanOptions(basePlan, options);
+  }
+  /**
+   * Apply sort/limit/cursor options to a query plan.
+   *
+   * @param plan - Base query plan
+   * @param options - Query options with sort/limit/cursor
+   * @returns Plan with options applied
+   */
+  applyPlanOptions(plan, options) {
     if (!options.sort && options.limit === void 0 && options.cursor === void 0) {
-      return basePlan;
+      return plan;
     }
     let indexedSort = false;
     let sortField;
@@ -6526,14 +6786,73 @@ var QueryOptimizer = class {
       }
     }
     return {
-      ...basePlan,
+      ...plan,
       indexedSort,
       sort: sortField && sortDirection ? { field: sortField, direction: sortDirection } : void 0,
       limit: options.limit,
       cursor: options.cursor
-      // replaces offset
     };
   }
+  /**
+   * Extract the relevant index query for a hinted attribute from the query tree.
+   * If the query directly references the attribute, build an index query from it.
+   * For compound (logical) queries, extract the matching child predicate.
+   * Falls back to { type: 'has' } when no matching predicate is found,
+   * retrieving all entries from the index for post-filtering.
+   * FTS query nodes also fall back to { type: 'has' } since full-text search
+   * queries are not compatible with regular index lookups.
+   *
+   * @param query - Original query tree
+   * @param attributeName - Hinted attribute name
+   * @returns Index query for the hinted attribute
+   */
+  buildHintedIndexQuery(query, attributeName) {
+    if (isSimpleQuery(query) && query.attribute === attributeName) {
+      return this.buildIndexQuery(query);
+    }
+    if (isFTSQuery(query)) {
+      return { type: "has" };
+    }
+    if (isLogicalQuery(query) && query.children) {
+      for (const child of query.children) {
+        if (isSimpleQuery(child) && child.attribute === attributeName) {
+          return this.buildIndexQuery(child);
+        }
+      }
+    }
+    return { type: "has" };
+  }
+  /**
+   * Try to optimize query as a point lookup.
+   * Returns a point lookup step if query is an equality or IN query on primary key.
+   *
+   * @param query - Query to check
+   * @returns Point lookup step or null
+   */
+  tryPointLookup(query) {
+    if (!isSimpleQuery(query)) {
+      return null;
+    }
+    const primaryKeyFields = ["_key", "key", "id"];
+    if (!primaryKeyFields.includes(query.attribute)) {
+      return null;
+    }
+    if (query.type === "eq") {
+      return {
+        type: "point-lookup",
+        key: query.value,
+        cost: 1
+      };
+    }
+    if (query.type === "in" && query.values) {
+      return {
+        type: "multi-point-lookup",
+        keys: query.values,
+        cost: query.values.length
+      };
+    }
+    return null;
+  }
   /**
    * Optimize a single query node.
    */
@@ -6922,6 +7241,9 @@ var QueryOptimizer = class {
    */
   estimateCost(step) {
     switch (step.type) {
+      case "point-lookup":
+      case "multi-point-lookup":
+        return step.cost;
       case "index-scan":
         return step.index.getRetrievalCost();
       case "full-scan":
@@ -6956,11 +7278,89 @@ var QueryOptimizer = class {
         return Number.MAX_SAFE_INTEGER;
     }
   }
+  /**
+   * Estimate distributed cost including network overhead.
+   *
+   * Network cost is assigned based on step type:
+   * - full-scan: broadcast to all nodes (highest cost)
+   * - index-scan: 0 if local partition, 5 if remote
+   * - point-lookup: 0 if local key, 5 if remote
+   * - intersection/union: aggregating results from multiple sources
+   *
+   * @param step - Plan step to estimate
+   * @param context - Distributed query context (optional)
+   * @returns Distributed cost breakdown
+   */
+  estimateDistributedCost(step, context) {
+    const baseCost = this.estimateCost(step);
+    if (!context?.isDistributed || context.nodeCount <= 1) {
+      return {
+        rows: baseCost,
+        cpu: baseCost,
+        network: 0,
+        io: 0
+      };
+    }
+    let networkCost = 0;
+    switch (step.type) {
+      case "full-scan":
+        networkCost = context.nodeCount * 10;
+        break;
+      case "index-scan":
+        networkCost = 5;
+        break;
+      case "point-lookup":
+        networkCost = 5;
+        break;
+      case "multi-point-lookup":
+        networkCost = Math.min(step.keys.length, context.nodeCount) * 5;
+        break;
+      case "intersection":
+      case "union":
+        networkCost = step.steps.length * 5;
+        break;
+      case "filter":
+        return this.estimateDistributedCost(step.source, context);
+      case "not":
+        networkCost = context.nodeCount * 5;
+        break;
+      case "fts-scan":
+        networkCost = Math.ceil(context.nodeCount / 2) * 5;
+        break;
+      case "fusion":
+        networkCost = step.steps.reduce(
+          (sum, s) => sum + this.estimateDistributedCost(s, context).network,
+          0
+        );
+        break;
+    }
+    return {
+      rows: baseCost,
+      cpu: baseCost,
+      network: networkCost,
+      io: context.usesStorage ? baseCost * 0.5 : 0
+    };
+  }
+  /**
+   * Get total distributed cost for a plan step.
+   * Convenience method combining estimateDistributedCost and calculateTotalCost.
+   *
+   * @param step - Plan step to estimate
+   * @param context - Distributed query context (optional)
+   * @returns Weighted total cost
+   */
+  getTotalDistributedCost(step, context) {
+    const distributedCost = this.estimateDistributedCost(step, context);
+    return calculateTotalCost(distributedCost);
+  }
   /**
    * Check if a plan step uses any indexes.
    */
   usesIndexes(step) {
     switch (step.type) {
+      case "point-lookup":
+      case "multi-point-lookup":
+        return true;
       case "index-scan":
         return true;
       case "full-scan":
@@ -9141,6 +9541,24 @@ var IndexedLWWMap = class extends LWWMap {
    */
   executePlan(step) {
     switch (step.type) {
+      case "point-lookup": {
+        const key = step.key;
+        const result = /* @__PURE__ */ new Set();
+        if (this.get(key) !== void 0) {
+          result.add(key);
+        }
+        return new SetResultSet(result, 1);
+      }
+      case "multi-point-lookup": {
+        const result = /* @__PURE__ */ new Set();
+        for (const key of step.keys) {
+          const k = key;
+          if (this.get(k) !== void 0) {
+            result.add(k);
+          }
+        }
+        return new SetResultSet(result, step.keys.length);
+      }
       case "index-scan":
         return step.index.retrieve(step.query);
       case "full-scan": {
@@ -12199,15 +12617,518 @@ function getSearchDebugger() {
 function resetSearchDebugger() {
   globalSearchDebugger = null;
 }
+
+// src/testing/VirtualClock.ts
+var RealClock = {
+  now: () => Date.now()
+};
+var VirtualClock = class {
+  /**
+   * @param initialTime Starting timestamp in milliseconds (default: 0)
+   */
+  constructor(initialTime = 0) {
+    if (!Number.isFinite(initialTime) || initialTime < 0) {
+      throw new Error("Initial time must be a non-negative finite number");
+    }
+    this.currentTime = initialTime;
+  }
+  /**
+   * Returns the current virtual time.
+   * Time remains frozen until advance() or set() is called.
+   */
+  now() {
+    return this.currentTime;
+  }
+  /**
+   * Advances time forward by the specified milliseconds.
+   * @param ms Milliseconds to advance (must be non-negative)
+   */
+  advance(ms) {
+    if (!Number.isFinite(ms) || ms < 0) {
+      throw new Error("Advance amount must be a non-negative finite number");
+    }
+    this.currentTime += ms;
+  }
+  /**
+   * Sets the clock to a specific time.
+   * Allows moving time forward or backward (useful for testing).
+   * @param time Absolute timestamp in milliseconds
+   */
+  set(time) {
+    if (!Number.isFinite(time) || time < 0) {
+      throw new Error("Time must be a non-negative finite number");
+    }
+    this.currentTime = time;
+  }
+  /**
+   * Resets the clock to zero.
+   */
+  reset() {
+    this.currentTime = 0;
+  }
+};
+
+// src/testing/SeededRNG.ts
+var SeededRNG = class {
+  /**
+   * @param seed Integer seed value. Same seed = same sequence.
+   */
+  constructor(seed) {
+    if (!Number.isInteger(seed)) {
+      throw new Error("Seed must be an integer");
+    }
+    this.state = seed >>> 0;
+    this.originalSeed = this.state;
+  }
+  /**
+   * Returns the original seed used to construct this RNG.
+   */
+  getSeed() {
+    return this.originalSeed;
+  }
+  /**
+   * Generates the next random number in [0, 1).
+   * Uses mulberry32 algorithm for deterministic, high-quality randomness.
+   */
+  random() {
+    let t = this.state += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    this.state = t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+  /**
+   * Generates a random integer in [min, max] (inclusive).
+   * @param min Minimum value (inclusive)
+   * @param max Maximum value (inclusive)
+   */
+  randomInt(min, max) {
+    if (!Number.isInteger(min) || !Number.isInteger(max)) {
+      throw new Error("Min and max must be integers");
+    }
+    if (min > max) {
+      throw new Error("Min must be less than or equal to max");
+    }
+    const range = max - min + 1;
+    return Math.floor(this.random() * range) + min;
+  }
+  /**
+   * Generates a random boolean value.
+   * @param probability Probability of returning true (default: 0.5)
+   */
+  randomBool(probability = 0.5) {
+    if (probability < 0 || probability > 1) {
+      throw new Error("Probability must be between 0 and 1");
+    }
+    return this.random() < probability;
+  }
+  /**
+   * Shuffles an array in place using Fisher-Yates algorithm.
+   * Returns the shuffled array.
+   * @param array Array to shuffle
+   */
+  shuffle(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+      const j = this.randomInt(0, i);
+      [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array;
+  }
+  /**
+   * Picks a random element from an array.
+   * @param array Array to pick from
+   * @returns Random element, or undefined if array is empty
+   */
+  pick(array) {
+    if (array.length === 0) return void 0;
+    return array[this.randomInt(0, array.length - 1)];
+  }
+  /**
+   * Resets the RNG to its original seed.
+   * Useful for reproducing a sequence from the start.
+   */
+  reset() {
+    this.state = this.originalSeed;
+  }
+};
+
+// src/testing/VirtualNetwork.ts
+var VirtualNetwork = class {
+  constructor(rng, clock) {
+    this.pendingMessages = [];
+    this.rng = rng;
+    this.clock = clock;
+    this.config = {
+      latencyMs: { min: 0, max: 0 },
+      packetLossRate: 0,
+      partitions: []
+    };
+  }
+  /**
+   * Updates network configuration.
+   * Partially updates existing config with provided values.
+   */
+  configure(config) {
+    if (config.latencyMs !== void 0) {
+      const { min, max } = config.latencyMs;
+      if (min < 0 || max < 0 || min > max) {
+        throw new Error("Invalid latency range");
+      }
+      this.config.latencyMs = config.latencyMs;
+    }
+    if (config.packetLossRate !== void 0) {
+      if (config.packetLossRate < 0 || config.packetLossRate > 1) {
+        throw new Error("Packet loss rate must be between 0 and 1");
+      }
+      this.config.packetLossRate = config.packetLossRate;
+    }
+    if (config.partitions !== void 0) {
+      this.config.partitions = config.partitions;
+    }
+  }
+  /**
+   * Sends a message through the network.
+   * Subject to packet loss, latency, and partition rules.
+   */
+  send(from, to, payload) {
+    if (this.rng.random() < this.config.packetLossRate) {
+      return;
+    }
+    if (this.isPartitioned(from, to)) {
+      return;
+    }
+    const latency = this.rng.randomInt(
+      this.config.latencyMs.min,
+      this.config.latencyMs.max
+    );
+    const scheduledTime = this.clock.now() + latency;
+    this.pendingMessages.push({
+      from,
+      to,
+      payload,
+      scheduledTime
+    });
+  }
+  /**
+   * Creates a network partition between two groups.
+   * Nodes in groupA cannot communicate with nodes in groupB.
+   */
+  partition(groupA, groupB) {
+    this.config.partitions.push(groupA, groupB);
+  }
+  /**
+   * Removes all network partitions.
+   */
+  heal() {
+    this.config.partitions = [];
+  }
+  /**
+   * Delivers all messages scheduled at or before the current time.
+   * @returns Array of delivered messages
+   */
+  tick() {
+    const currentTime = this.clock.now();
+    const delivered = [];
+    const remaining = [];
+    for (const msg of this.pendingMessages) {
+      if (msg.scheduledTime <= currentTime) {
+        delivered.push(msg);
+      } else {
+        remaining.push(msg);
+      }
+    }
+    this.pendingMessages = remaining;
+    return delivered;
+  }
+  /**
+   * Returns the number of messages currently in flight.
+   */
+  getPendingCount() {
+    return this.pendingMessages.length;
+  }
+  /**
+   * Clears all pending messages.
+   */
+  clear() {
+    this.pendingMessages = [];
+  }
+  /**
+   * Checks if two nodes are partitioned from each other.
+   */
+  isPartitioned(from, to) {
+    for (let i = 0; i < this.config.partitions.length; i += 2) {
+      const groupA = this.config.partitions[i];
+      const groupB = this.config.partitions[i + 1];
+      if (groupA.includes(from) && groupB.includes(to) || groupB.includes(from) && groupA.includes(to)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Returns all pending messages (useful for debugging).
+   */
+  getPendingMessages() {
+    return [...this.pendingMessages];
+  }
+};
+
+// src/testing/InvariantChecker.ts
+var InvariantChecker = class {
+  constructor() {
+    this.invariants = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Adds an invariant to be checked.
+   * @param name Unique name for this invariant
+   * @param check Function that returns true if invariant holds
+   */
+  addInvariant(name, check) {
+    if (this.invariants.has(name)) {
+      throw new Error(`Invariant '${name}' already exists`);
+    }
+    this.invariants.set(name, check);
+  }
+  /**
+   * Removes an invariant by name.
+   */
+  removeInvariant(name) {
+    return this.invariants.delete(name);
+  }
+  /**
+   * Verifies all invariants against the provided state.
+   * @returns Result with pass/fail status and list of failed invariants
+   */
+  verify(state) {
+    const failures = [];
+    for (const [name, check] of this.invariants.entries()) {
+      try {
+        if (!check(state)) {
+          failures.push(name);
+        }
+      } catch (error) {
+        failures.push(`${name} (exception: ${error instanceof Error ? error.message : String(error)})`);
+      }
+    }
+    return {
+      passed: failures.length === 0,
+      failures
+    };
+  }
+  /**
+   * Returns the number of registered invariants.
+   */
+  get count() {
+    return this.invariants.size;
+  }
+  /**
+   * Clears all invariants.
+   */
+  clear() {
+    this.invariants.clear();
+  }
+};
+var CRDTInvariants = {
+  /**
+   * Verifies LWW-Map convergence: all maps contain the same values for same keys.
+   */
+  lwwConvergence: (maps) => {
+    if (maps.length < 2) return true;
+    const reference = maps[0];
+    const refKeys = new Set(reference.allKeys());
+    for (let i = 1; i < maps.length; i++) {
+      const other = maps[i];
+      const otherKeys = new Set(other.allKeys());
+      if (refKeys.size !== otherKeys.size) return false;
+      for (const key of refKeys) {
+        if (!otherKeys.has(key)) return false;
+      }
+      for (const key of refKeys) {
+        const refRecord = reference.getRecord(key);
+        const otherRecord = other.getRecord(key);
+        if (!refRecord || !otherRecord) {
+          if (refRecord !== otherRecord) return false;
+          continue;
+        }
+        if (refRecord.value !== otherRecord.value) return false;
+        if (HLC.compare(refRecord.timestamp, otherRecord.timestamp) !== 0) {
+          return false;
+        }
+      }
+    }
+    return true;
+  },
+  /**
+   * Verifies OR-Map convergence: all maps contain the same values for same keys.
+   */
+  orMapConvergence: (maps) => {
+    if (maps.length < 2) return true;
+    const reference = maps[0];
+    const refKeys = reference.allKeys();
+    for (let i = 1; i < maps.length; i++) {
+      const other = maps[i];
+      const otherKeys = new Set(other.allKeys());
+      if (refKeys.length !== otherKeys.size) return false;
+      for (const key of refKeys) {
+        if (!otherKeys.has(key)) return false;
+      }
+      for (const key of refKeys) {
+        const refRecords = reference.getRecords(key);
+        const otherRecords = other.getRecords(key);
+        if (refRecords.length !== otherRecords.length) return false;
+        const refSorted = [...refRecords].sort((a, b) => a.tag.localeCompare(b.tag));
+        const otherSorted = [...otherRecords].sort((a, b) => a.tag.localeCompare(b.tag));
+        for (let j = 0; j < refSorted.length; j++) {
+          if (refSorted[j].tag !== otherSorted[j].tag) return false;
+          if (refSorted[j].value !== otherSorted[j].value) return false;
+          if (HLC.compare(refSorted[j].timestamp, otherSorted[j].timestamp) !== 0) {
+            return false;
+          }
+        }
+      }
+      const refTombstones = new Set(reference.getTombstones());
+      const otherTombstones = new Set(other.getTombstones());
+      if (refTombstones.size !== otherTombstones.size) return false;
+      for (const tag of refTombstones) {
+        if (!otherTombstones.has(tag)) return false;
+      }
+    }
+    return true;
+  },
+  /**
+   * Verifies HLC monotonicity: timestamps are strictly increasing.
+   */
+  hlcMonotonicity: (timestamps) => {
+    for (let i = 1; i < timestamps.length; i++) {
+      if (HLC.compare(timestamps[i - 1], timestamps[i]) >= 0) {
+        return false;
+      }
+    }
+    return true;
+  },
+  /**
+   * Verifies Merkle tree consistency: trees with same data have same root hash.
+   */
+  merkleConsistency: (trees) => {
+    if (trees.length < 2) return true;
+    const referenceHash = trees[0].getRootHash();
+    for (let i = 1; i < trees.length; i++) {
+      if (trees[i].getRootHash() !== referenceHash) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/testing/ScenarioRunner.ts
+var ScenarioRunner = class {
+  constructor(config) {
+    if (!config.nodes || config.nodes.length === 0) {
+      throw new Error("Scenario must have at least one node");
+    }
+    if (config.duration <= 0) {
+      throw new Error("Duration must be positive");
+    }
+    this.seed = config.seed ?? Math.floor(Math.random() * 2147483647);
+    this.config = {
+      ...config,
+      seed: this.seed,
+      tickInterval: config.tickInterval ?? 1
+    };
+    this.clock = new VirtualClock(0);
+    this.rng = new SeededRNG(this.seed);
+    this.network = new VirtualNetwork(this.rng, this.clock);
+  }
+  /**
+   * Returns the seed used for this scenario.
+   */
+  getSeed() {
+    return this.seed;
+  }
+  /**
+   * Returns the virtual clock instance.
+   */
+  getClock() {
+    return this.clock;
+  }
+  /**
+   * Returns the seeded RNG instance.
+   */
+  getRNG() {
+    return this.rng;
+  }
+  /**
+   * Returns the virtual network instance.
+   */
+  getNetwork() {
+    return this.network;
+  }
+  /**
+   * Returns the list of nodes in this scenario.
+   */
+  getNodes() {
+    return [...this.config.nodes];
+  }
+  /**
+   * Executes the simulation scenario.
+   *
+   * @param setup Called once before simulation starts. Initialize state here.
+   * @param step Called on each tick. Perform operations and message delivery.
+   * @param invariants Checker for verifying correctness throughout execution.
+   * @returns Result with pass/fail status and captured state
+   */
+  run(setup, step, invariants) {
+    const finalStates = /* @__PURE__ */ new Map();
+    const invariantFailures = [];
+    setup(this);
+    let tickCount = 0;
+    const tickInterval = this.config.tickInterval;
+    const endTime = this.config.duration;
+    while (this.clock.now() < endTime) {
+      this.clock.advance(tickInterval);
+      tickCount++;
+      step(this, tickCount);
+      const delivered = this.network.tick();
+      if (delivered.length > 0) {
+        finalStates.set(`_tick_${tickCount}_delivered`, delivered.length);
+      }
+    }
+    const result = invariants.verify(null);
+    if (!result.passed) {
+      invariantFailures.push(...result.failures);
+    }
+    return {
+      seed: this.seed,
+      passed: invariantFailures.length === 0,
+      ticks: tickCount,
+      invariantFailures,
+      finalStates
+    };
+  }
+  /**
+   * Stores state for a node (useful for capturing final state).
+   */
+  setState(nodeId, state) {
+    if (!this.config.nodes.includes(nodeId)) {
+      throw new Error(`Unknown node: ${nodeId}`);
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AuthAckMessageSchema,
   AuthFailMessageSchema,
   AuthMessageSchema,
+  AuthRequiredMessageSchema,
   BM25Scorer,
   BatchMessageSchema,
   BuiltInProcessors,
   BuiltInResolvers,
+  COST_WEIGHTS,
   CRDTDebugger,
+  CRDTInvariants,
+  ChangeEventTypeSchema,
   ClientOpMessageSchema,
   ClientOpSchema,
   ClusterSearchReqMessageSchema,
@@ -12249,6 +13170,7 @@ function resetSearchDebugger() {
   DEFAULT_RESOLVER_RATE_LIMITS,
   DEFAULT_STOP_WORDS,
   DEFAULT_WRITE_CONCERN_TIMEOUT,
+  DeltaRecordSchema,
   ENGLISH_STOPWORDS,
   EntryProcessBatchRequestSchema,
   EntryProcessBatchResponseSchema,
@@ -12257,6 +13179,7 @@ function resetSearchDebugger() {
   EntryProcessResponseSchema,
   EntryProcessorDefSchema,
   EntryProcessorSchema,
+  ErrorMessageSchema,
   EventJournalImpl,
   FORBIDDEN_PATTERNS,
   FTSInvertedIndex,
@@ -12268,12 +13191,18 @@ function resetSearchDebugger() {
   GcPrunePayloadSchema,
   HLC,
   HashIndex,
-  HybridQueryDeltaPayloadSchema,
-  HybridQueryRespPayloadSchema,
+  HttpQueryRequestSchema,
+  HttpQueryResultSchema,
+  HttpSearchRequestSchema,
+  HttpSearchResultSchema,
+  HttpSyncErrorSchema,
+  HttpSyncRequestSchema,
+  HttpSyncResponseSchema,
   IndexRegistry,
   IndexedLWWMap,
   IndexedORMap,
   IntersectionResultSet,
+  InvariantChecker,
   InvertedIndex,
   JournalEventDataSchema,
   JournalEventMessageSchema,
@@ -12289,11 +13218,14 @@ function resetSearchDebugger() {
   ListResolversRequestSchema,
   ListResolversResponseSchema,
   LiveQueryManager,
+  LockGrantedMessageSchema,
   LockGrantedPayloadSchema,
   LockReleaseSchema,
+  LockReleasedMessageSchema,
   LockReleasedPayloadSchema,
   LockRequestSchema,
   LowercaseFilter,
+  MapDeltaSchema,
   MaxLengthFilter,
   MergeRejectedMessageSchema,
   MerkleReqBucketMessageSchema,
@@ -12303,9 +13235,11 @@ function resetSearchDebugger() {
   MultiValueAttribute,
   NGramTokenizer,
   NavigableIndex,
+  NodeInfoSchema,
   ORMap,
   ORMapDiffRequestSchema,
   ORMapDiffResponseSchema,
+  ORMapEntrySchema,
   ORMapMerkleReqBucketSchema,
   ORMapMerkleTree,
   ORMapPushDiffSchema,
@@ -12321,6 +13255,9 @@ function resetSearchDebugger() {
   PARTITION_COUNT,
   PNCounterImpl,
   PNCounterStateObjectSchema,
+  PartitionInfoSchema,
+  PartitionMapMessageSchema,
+  PartitionMapPayloadSchema,
   PartitionMapRequestSchema,
   PartitionState,
   PingMessageSchema,
@@ -12338,10 +13275,12 @@ function resetSearchDebugger() {
   QueryUpdateMessageSchema,
   QueryUpdatePayloadSchema,
   RESOLVER_FORBIDDEN_PATTERNS,
+  RealClock,
   ReciprocalRankFusion,
   RegisterResolverRequestSchema,
   RegisterResolverResponseSchema,
   Ringbuffer,
+  ScenarioRunner,
   SearchCursor,
   SearchDebugger,
   SearchMessageSchema,
@@ -12356,6 +13295,7 @@ function resetSearchDebugger() {
   SearchUpdateMessageSchema,
   SearchUpdatePayloadSchema,
   SearchUpdateTypeSchema,
+  SeededRNG,
   ServerBatchEventMessageSchema,
   ServerEventMessageSchema,
   ServerEventPayloadSchema,
@@ -12367,6 +13307,8 @@ function resetSearchDebugger() {
   StandingQueryRegistry,
   StopWordFilter,
   SyncInitMessageSchema,
+  SyncMapEntrySchema,
+  SyncResetRequiredMessageSchema,
   SyncResetRequiredPayloadSchema,
   SyncRespBucketsMessageSchema,
   SyncRespLeafMessageSchema,
@@ -12382,11 +13324,14 @@ function resetSearchDebugger() {
   UniqueFilter,
   UnregisterResolverRequestSchema,
   UnregisterResolverResponseSchema,
+  VirtualClock,
+  VirtualNetwork,
   WRITE_CONCERN_ORDER,
   WhitespaceTokenizer,
   WordBoundaryTokenizer,
   WriteConcern,
   WriteConcernSchema,
+  calculateTotalCost,
   combineHashes,
   compareHLCTimestamps,
   compareTimestamps,
@@ -12396,7 +13341,6 @@ function resetSearchDebugger() {
   decodeBase64Url,
   deepMerge,
   deserialize,
-  disableNativeHash,
   encodeBase64Url,
   evaluatePredicate,
   getCRDTDebugger,
@@ -12408,13 +13352,11 @@ function resetSearchDebugger() {
   hashString,
   isLogicalQuery,
   isSimpleQuery,
-  isUsingNativeHash,
   isWriteConcernAchieved,
   logger,
   multiAttribute,
   porterStem,
   resetCRDTDebugger,
-  resetNativeHash,
   resetSearchDebugger,
   serialize,
   simpleAttribute,