@topgunbuild/core 0.10.0 → 0.11.0

package/dist/index.js

@@ -30,11 +30,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AuthFailMessageSchema: () => AuthFailMessageSchema,
   AuthMessageSchema: () => AuthMessageSchema,
   BM25Scorer: () => BM25Scorer,
   BatchMessageSchema: () => BatchMessageSchema,
   BuiltInProcessors: () => BuiltInProcessors,
   BuiltInResolvers: () => BuiltInResolvers,
+  COST_WEIGHTS: () => COST_WEIGHTS,
+  CRDTDebugger: () => CRDTDebugger,
+  CRDTInvariants: () => CRDTInvariants,
   ClientOpMessageSchema: () => ClientOpMessageSchema,
   ClientOpSchema: () => ClientOpSchema,
   ClusterSearchReqMessageSchema: () => ClusterSearchReqMessageSchema,
@@ -76,6 +80,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,
@@ -91,12 +96,24 @@ __export(index_exports, {
   FallbackIndex: () => FallbackIndex,
   FilteringResultSet: () => FilteringResultSet,
   FullTextIndex: () => FullTextIndex,
+  GcPruneMessageSchema: () => GcPruneMessageSchema,
+  GcPrunePayloadSchema: () => GcPrunePayloadSchema,
   HLC: () => HLC,
   HashIndex: () => HashIndex,
+  HttpQueryRequestSchema: () => HttpQueryRequestSchema,
+  HttpQueryResultSchema: () => HttpQueryResultSchema,
+  HttpSearchRequestSchema: () => HttpSearchRequestSchema,
+  HttpSearchResultSchema: () => HttpSearchResultSchema,
+  HttpSyncErrorSchema: () => HttpSyncErrorSchema,
+  HttpSyncRequestSchema: () => HttpSyncRequestSchema,
+  HttpSyncResponseSchema: () => HttpSyncResponseSchema,
+  HybridQueryDeltaPayloadSchema: () => HybridQueryDeltaPayloadSchema,
+  HybridQueryRespPayloadSchema: () => HybridQueryRespPayloadSchema,
   IndexRegistry: () => IndexRegistry,
   IndexedLWWMap: () => IndexedLWWMap,
   IndexedORMap: () => IndexedORMap,
   IntersectionResultSet: () => IntersectionResultSet,
+  InvariantChecker: () => InvariantChecker,
   InvertedIndex: () => InvertedIndex,
   JournalEventDataSchema: () => JournalEventDataSchema,
   JournalEventMessageSchema: () => JournalEventMessageSchema,
@@ -112,9 +129,12 @@ __export(index_exports, {
   ListResolversRequestSchema: () => ListResolversRequestSchema,
   ListResolversResponseSchema: () => ListResolversResponseSchema,
   LiveQueryManager: () => LiveQueryManager,
+  LockGrantedPayloadSchema: () => LockGrantedPayloadSchema,
   LockReleaseSchema: () => LockReleaseSchema,
+  LockReleasedPayloadSchema: () => LockReleasedPayloadSchema,
   LockRequestSchema: () => LockRequestSchema,
   LowercaseFilter: () => LowercaseFilter,
+  MapDeltaSchema: () => MapDeltaSchema,
   MaxLengthFilter: () => MaxLengthFilter,
   MergeRejectedMessageSchema: () => MergeRejectedMessageSchema,
   MerkleReqBucketMessageSchema: () => MerkleReqBucketMessageSchema,
@@ -156,12 +176,17 @@ __export(index_exports, {
   QuerySchema: () => QuerySchema,
   QuerySubMessageSchema: () => QuerySubMessageSchema,
   QueryUnsubMessageSchema: () => QueryUnsubMessageSchema,
+  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,
   SearchOptionsSchema: () => SearchOptionsSchema,
   SearchPayloadSchema: () => SearchPayloadSchema,
@@ -174,6 +199,10 @@ __export(index_exports, {
   SearchUpdateMessageSchema: () => SearchUpdateMessageSchema,
   SearchUpdatePayloadSchema: () => SearchUpdatePayloadSchema,
   SearchUpdateTypeSchema: () => SearchUpdateTypeSchema,
+  SeededRNG: () => SeededRNG,
+  ServerBatchEventMessageSchema: () => ServerBatchEventMessageSchema,
+  ServerEventMessageSchema: () => ServerEventMessageSchema,
+  ServerEventPayloadSchema: () => ServerEventPayloadSchema,
   SetResultSet: () => SetResultSet,
   SimpleAttribute: () => SimpleAttribute,
   SortedMap: () => SortedMap,
@@ -182,6 +211,8 @@ __export(index_exports, {
   StandingQueryRegistry: () => StandingQueryRegistry,
   StopWordFilter: () => StopWordFilter,
   SyncInitMessageSchema: () => SyncInitMessageSchema,
+  SyncMapEntrySchema: () => SyncMapEntrySchema,
+  SyncResetRequiredPayloadSchema: () => SyncResetRequiredPayloadSchema,
   SyncRespBucketsMessageSchema: () => SyncRespBucketsMessageSchema,
   SyncRespLeafMessageSchema: () => SyncRespLeafMessageSchema,
   SyncRespRootMessageSchema: () => SyncRespRootMessageSchema,
@@ -196,11 +227,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,
@@ -213,7 +247,9 @@ __export(index_exports, {
   disableNativeHash: () => disableNativeHash,
   encodeBase64Url: () => encodeBase64Url,
   evaluatePredicate: () => evaluatePredicate,
+  getCRDTDebugger: () => getCRDTDebugger,
   getHighestWriteConcernLevel: () => getHighestWriteConcernLevel,
+  getSearchDebugger: () => getSearchDebugger,
   hashORMapEntry: () => hashORMapEntry,
   hashORMapRecord: () => hashORMapRecord,
   hashObject: () => hashObject,
@@ -222,9 +258,12 @@ __export(index_exports, {
   isSimpleQuery: () => isSimpleQuery,
   isUsingNativeHash: () => isUsingNativeHash,
   isWriteConcernAchieved: () => isWriteConcernAchieved,
+  logger: () => logger,
   multiAttribute: () => multiAttribute,
   porterStem: () => porterStem,
+  resetCRDTDebugger: () => resetCRDTDebugger,
   resetNativeHash: () => resetNativeHash,
+  resetSearchDebugger: () => resetSearchDebugger,
   serialize: () => serialize,
   simpleAttribute: () => simpleAttribute,
   timestampToString: () => timestampToString,
@@ -233,22 +272,48 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/utils/logger.ts
+var import_pino = __toESM(require("pino"));
+var logLevel = typeof process !== "undefined" && process.env && process.env.LOG_LEVEL || "info";
+var logger = (0, import_pino.default)({
+  level: logLevel,
+  browser: {
+    asObject: true
+  }
+});
+
 // src/HLC.ts
-var _HLC = class _HLC {
-  constructor(nodeId) {
+var HLC = class {
+  constructor(nodeId, options = {}) {
     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;
   }
   get getNodeId() {
     return this.nodeId;
   }
+  get getStrictMode() {
+    return this.strictMode;
+  }
+  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;
@@ -266,9 +331,19 @@ var _HLC = class _HLC {
    * Must be called whenever a message/event is received from another node.
    */
   update(remote) {
-    const systemTime = Date.now();
-    if (remote.millis > systemTime + _HLC.MAX_DRIFT) {
-      console.warn(`Clock drift detected: Remote time ${remote.millis} is far ahead of local ${systemTime}`);
+    const systemTime = this.clockSource.now();
+    const drift = remote.millis - 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)`);
+      } else {
+        logger.warn({
+          drift,
+          remoteMillis: remote.millis,
+          localMillis: systemTime,
+          maxDriftMs: this.maxDriftMs
+        }, "Clock drift detected");
+      }
     }
     const maxMillis = Math.max(this.lastMillis, systemTime, remote.millis);
     if (maxMillis === this.lastMillis && maxMillis === remote.millis) {
@@ -317,9 +392,6 @@ var _HLC = class _HLC {
     };
   }
 };
-// Max allowable drift in milliseconds (1 minute)
-_HLC.MAX_DRIFT = 6e4;
-var HLC = _HLC;
 
 // src/utils/hash.ts
 var nativeHash = null;
@@ -543,7 +615,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;
       }
@@ -620,7 +692,7 @@ var LWWMap = class {
    */
   entries() {
     const iterator = this.data.entries();
-    const now = Date.now();
+    const clockSource = this.hlc.getClockSource();
     return {
       [Symbol.iterator]() {
         return this;
@@ -630,7 +702,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;
             }
@@ -967,7 +1039,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) {
@@ -987,7 +1059,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) {
@@ -1508,7 +1580,7 @@ var EventJournalImpl = class {
       try {
         listener(event);
       } catch (e) {
-        console.error("EventJournal listener error:", e);
+        logger.error({ err: e, context: "listener" }, "EventJournal listener error");
       }
     }
     return event;
@@ -1554,7 +1626,7 @@ var EventJournalImpl = class {
         try {
           listener(event);
         } catch (e) {
-          console.error("EventJournal replay error:", e);
+          logger.error({ err: e, context: "replay" }, "EventJournal replay error");
         }
       }
     }
@@ -2213,7 +2285,7 @@ var Predicates = class {
   static containsAny(attribute, values) {
     return { op: "containsAny", attribute, value: values };
   }
-  // ============== Full-Text Search Predicates (Phase 12) ==============
+  // ============== Full-Text Search Predicates ==============
   /**
    * Create a 'match' predicate for full-text search.
    * Uses BM25 scoring to find relevant documents.
@@ -2357,7 +2429,7 @@ function evaluatePredicate(predicate, data) {
   }
 }
 
-// src/schemas.ts
+// src/schemas/base-schemas.ts
 var import_zod3 = require("zod");
 var WriteConcernSchema = import_zod3.z.enum([
   "FIRE_AND_FORGET",
@@ -2407,35 +2479,16 @@ var QuerySchema = import_zod3.z.object({
   sort: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.enum(["asc", "desc"])).optional(),
   limit: import_zod3.z.number().optional(),
   cursor: import_zod3.z.string().optional()
-  // Phase 14.1: replaces offset
-});
-var CursorStatusSchema = import_zod3.z.enum(["valid", "expired", "invalid", "none"]);
-var QueryRespPayloadSchema = import_zod3.z.object({
-  queryId: import_zod3.z.string(),
-  results: import_zod3.z.array(import_zod3.z.object({
-    key: import_zod3.z.string(),
-    value: import_zod3.z.unknown()
-  })),
-  nextCursor: import_zod3.z.string().optional(),
-  hasMore: import_zod3.z.boolean().optional(),
-  /** Debug info: status of input cursor processing */
-  cursorStatus: CursorStatusSchema.optional()
-});
-var QueryRespMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("QUERY_RESP"),
-  payload: QueryRespPayloadSchema
+  // Replaces offset for pagination
 });
 var ClientOpSchema = import_zod3.z.object({
   id: import_zod3.z.string().optional(),
   mapName: import_zod3.z.string(),
   key: import_zod3.z.string(),
-  // Permissive opType to match ServerCoordinator behavior logic
-  // It can be 'REMOVE', 'OR_ADD', 'OR_REMOVE' or undefined/other (implies PUT/LWW)
   opType: import_zod3.z.string().optional(),
   record: LWWRecordSchema.nullable().optional(),
   orRecord: ORMapRecordSchema.nullable().optional(),
   orTag: import_zod3.z.string().nullable().optional(),
-  // Write Concern fields (Phase 5.01)
   writeConcern: WriteConcernSchema.optional(),
   timeout: import_zod3.z.number().optional()
 });
@@ -2443,548 +2496,751 @@ var AuthMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("AUTH"),
   token: import_zod3.z.string()
 });
-var QuerySubMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("QUERY_SUB"),
-  payload: import_zod3.z.object({
-    queryId: import_zod3.z.string(),
-    mapName: import_zod3.z.string(),
-    query: QuerySchema
-  })
-});
-var QueryUnsubMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("QUERY_UNSUB"),
-  payload: import_zod3.z.object({
-    queryId: import_zod3.z.string()
-  })
-});
-var ClientOpMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLIENT_OP"),
+
+// src/schemas/sync-schemas.ts
+var import_zod4 = require("zod");
+var ClientOpMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("CLIENT_OP"),
   payload: ClientOpSchema
 });
-var OpBatchMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("OP_BATCH"),
-  payload: import_zod3.z.object({
-    ops: import_zod3.z.array(ClientOpSchema),
-    // Batch-level Write Concern (can be overridden per-op)
+var OpBatchMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("OP_BATCH"),
+  payload: import_zod4.z.object({
+    ops: import_zod4.z.array(ClientOpSchema),
     writeConcern: WriteConcernSchema.optional(),
-    timeout: import_zod3.z.number().optional()
+    timeout: import_zod4.z.number().optional()
   })
 });
-var SyncInitMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SYNC_INIT"),
-  mapName: import_zod3.z.string(),
-  lastSyncTimestamp: import_zod3.z.number().optional()
+var SyncInitMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("SYNC_INIT"),
+  mapName: import_zod4.z.string(),
+  lastSyncTimestamp: import_zod4.z.number().optional()
 });
-var SyncRespRootMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SYNC_RESP_ROOT"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    rootHash: import_zod3.z.number(),
+var SyncRespRootMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("SYNC_RESP_ROOT"),
+  payload: import_zod4.z.object({
+    mapName: import_zod4.z.string(),
+    rootHash: import_zod4.z.number(),
     timestamp: TimestampSchema
   })
 });
-var SyncRespBucketsMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SYNC_RESP_BUCKETS"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    path: import_zod3.z.string(),
-    buckets: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number())
+var SyncRespBucketsMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("SYNC_RESP_BUCKETS"),
+  payload: import_zod4.z.object({
+    mapName: import_zod4.z.string(),
+    path: import_zod4.z.string(),
+    buckets: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.number())
   })
 });
-var SyncRespLeafMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SYNC_RESP_LEAF"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    path: import_zod3.z.string(),
-    records: import_zod3.z.array(import_zod3.z.object({
-      key: import_zod3.z.string(),
+var SyncRespLeafMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("SYNC_RESP_LEAF"),
+  payload: import_zod4.z.object({
+    mapName: import_zod4.z.string(),
+    path: import_zod4.z.string(),
+    records: import_zod4.z.array(import_zod4.z.object({
+      key: import_zod4.z.string(),
       record: LWWRecordSchema
     }))
   })
 });
-var MerkleReqBucketMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("MERKLE_REQ_BUCKET"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    path: import_zod3.z.string()
+var MerkleReqBucketMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("MERKLE_REQ_BUCKET"),
+  payload: import_zod4.z.object({
+    mapName: import_zod4.z.string(),
+    path: import_zod4.z.string()
+  })
+});
+var ORMapSyncInitSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("ORMAP_SYNC_INIT"),
+  mapName: import_zod4.z.string(),
+  rootHash: import_zod4.z.number(),
+  bucketHashes: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.number()),
+  lastSyncTimestamp: import_zod4.z.number().optional()
+});
+var ORMapSyncRespRootSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("ORMAP_SYNC_RESP_ROOT"),
+  payload: import_zod4.z.object({
+    mapName: import_zod4.z.string(),
+    rootHash: import_zod4.z.number(),
+    timestamp: TimestampSchema
   })
 });
-var LockRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("LOCK_REQUEST"),
-  payload: import_zod3.z.object({
-    requestId: import_zod3.z.string(),
-    name: import_zod3.z.string(),
-    ttl: import_zod3.z.number().optional()
+var ORMapSyncRespBucketsSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("ORMAP_SYNC_RESP_BUCKETS"),
+  payload: import_zod4.z.object({
+    mapName: import_zod4.z.string(),
+    path: import_zod4.z.string(),
+    buckets: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.number())
   })
 });
-var LockReleaseSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("LOCK_RELEASE"),
-  payload: import_zod3.z.object({
-    requestId: import_zod3.z.string().optional(),
-    name: import_zod3.z.string(),
-    fencingToken: import_zod3.z.number()
+var ORMapMerkleReqBucketSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("ORMAP_MERKLE_REQ_BUCKET"),
+  payload: import_zod4.z.object({
+    mapName: import_zod4.z.string(),
+    path: import_zod4.z.string()
   })
 });
-var TopicSubSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("TOPIC_SUB"),
-  payload: import_zod3.z.object({
-    topic: import_zod3.z.string()
+var ORMapSyncRespLeafSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("ORMAP_SYNC_RESP_LEAF"),
+  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())
+    }))
   })
 });
-var TopicUnsubSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("TOPIC_UNSUB"),
-  payload: import_zod3.z.object({
-    topic: import_zod3.z.string()
+var ORMapDiffRequestSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("ORMAP_DIFF_REQUEST"),
+  payload: import_zod4.z.object({
+    mapName: import_zod4.z.string(),
+    keys: import_zod4.z.array(import_zod4.z.string())
   })
 });
-var TopicPubSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("TOPIC_PUB"),
-  payload: import_zod3.z.object({
-    topic: import_zod3.z.string(),
-    data: import_zod3.z.any()
+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())
+    }))
   })
 });
-var TopicMessageEventSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("TOPIC_MESSAGE"),
-  payload: import_zod3.z.object({
-    topic: import_zod3.z.string(),
-    data: import_zod3.z.any(),
-    publisherId: import_zod3.z.string().optional(),
-    timestamp: import_zod3.z.number()
+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())
+    }))
   })
 });
-var PNCounterStateObjectSchema = import_zod3.z.object({
-  p: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()),
-  // positive counts per node
-  n: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number())
-  // negative counts per node
+var OpResultSchema = import_zod4.z.object({
+  opId: import_zod4.z.string(),
+  success: import_zod4.z.boolean(),
+  achievedLevel: WriteConcernSchema,
+  error: import_zod4.z.string().optional()
 });
-var CounterRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("COUNTER_REQUEST"),
-  payload: import_zod3.z.object({
-    name: import_zod3.z.string()
+var OpAckMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("OP_ACK"),
+  payload: import_zod4.z.object({
+    lastId: import_zod4.z.string(),
+    achievedLevel: WriteConcernSchema.optional(),
+    results: import_zod4.z.array(OpResultSchema).optional()
   })
 });
-var CounterSyncSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("COUNTER_SYNC"),
-  payload: import_zod3.z.object({
-    name: import_zod3.z.string(),
-    state: PNCounterStateObjectSchema
+var OpRejectedMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("OP_REJECTED"),
+  payload: import_zod4.z.object({
+    opId: import_zod4.z.string(),
+    reason: import_zod4.z.string(),
+    code: import_zod4.z.number().optional()
   })
 });
-var CounterResponseSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("COUNTER_RESPONSE"),
-  payload: import_zod3.z.object({
-    name: import_zod3.z.string(),
-    state: PNCounterStateObjectSchema
+var BatchMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("BATCH"),
+  count: import_zod4.z.number(),
+  data: import_zod4.z.instanceof(Uint8Array)
+});
+
+// src/schemas/query-schemas.ts
+var import_zod5 = require("zod");
+var QuerySubMessageSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("QUERY_SUB"),
+  payload: import_zod5.z.object({
+    queryId: import_zod5.z.string(),
+    mapName: import_zod5.z.string(),
+    query: QuerySchema
   })
 });
-var CounterUpdateSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("COUNTER_UPDATE"),
-  payload: import_zod3.z.object({
-    name: import_zod3.z.string(),
-    state: PNCounterStateObjectSchema
+var QueryUnsubMessageSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("QUERY_UNSUB"),
+  payload: import_zod5.z.object({
+    queryId: import_zod5.z.string()
   })
 });
-var PingMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("PING"),
-  timestamp: import_zod3.z.number()
-  // Client's Date.now()
+var CursorStatusSchema = import_zod5.z.enum(["valid", "expired", "invalid", "none"]);
+var QueryRespPayloadSchema = import_zod5.z.object({
+  queryId: import_zod5.z.string(),
+  results: import_zod5.z.array(import_zod5.z.object({
+    key: import_zod5.z.string(),
+    value: import_zod5.z.unknown()
+  })),
+  nextCursor: import_zod5.z.string().optional(),
+  hasMore: import_zod5.z.boolean().optional(),
+  cursorStatus: CursorStatusSchema.optional()
 });
-var PongMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("PONG"),
-  timestamp: import_zod3.z.number(),
-  // Echo back client's timestamp
-  serverTime: import_zod3.z.number()
-  // Server's Date.now() (for clock skew detection)
+var QueryRespMessageSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("QUERY_RESP"),
+  payload: QueryRespPayloadSchema
 });
-var BatchMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("BATCH"),
-  count: import_zod3.z.number(),
-  data: import_zod3.z.instanceof(Uint8Array)
+
+// src/schemas/search-schemas.ts
+var import_zod6 = require("zod");
+var SearchOptionsSchema = import_zod6.z.object({
+  limit: import_zod6.z.number().optional(),
+  minScore: import_zod6.z.number().optional(),
+  boost: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.number()).optional()
 });
-var ORMapSyncInitSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ORMAP_SYNC_INIT"),
-  mapName: import_zod3.z.string(),
-  rootHash: import_zod3.z.number(),
-  bucketHashes: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()),
-  // path -> hash
-  lastSyncTimestamp: import_zod3.z.number().optional()
+var SearchPayloadSchema = import_zod6.z.object({
+  requestId: import_zod6.z.string(),
+  mapName: import_zod6.z.string(),
+  query: import_zod6.z.string(),
+  options: SearchOptionsSchema.optional()
 });
-var ORMapSyncRespRootSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ORMAP_SYNC_RESP_ROOT"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    rootHash: import_zod3.z.number(),
-    timestamp: TimestampSchema
+var SearchMessageSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SEARCH"),
+  payload: SearchPayloadSchema
+});
+var SearchRespPayloadSchema = import_zod6.z.object({
+  requestId: import_zod6.z.string(),
+  results: import_zod6.z.array(import_zod6.z.object({
+    key: import_zod6.z.string(),
+    value: import_zod6.z.unknown(),
+    score: import_zod6.z.number(),
+    matchedTerms: import_zod6.z.array(import_zod6.z.string())
+  })),
+  totalCount: import_zod6.z.number(),
+  error: import_zod6.z.string().optional()
+});
+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 SearchSubPayloadSchema = import_zod6.z.object({
+  subscriptionId: import_zod6.z.string(),
+  mapName: import_zod6.z.string(),
+  query: import_zod6.z.string(),
+  options: SearchOptionsSchema.optional()
+});
+var SearchSubMessageSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SEARCH_SUB"),
+  payload: SearchSubPayloadSchema
+});
+var SearchUpdatePayloadSchema = import_zod6.z.object({
+  subscriptionId: import_zod6.z.string(),
+  key: import_zod6.z.string(),
+  value: import_zod6.z.unknown(),
+  score: import_zod6.z.number(),
+  matchedTerms: import_zod6.z.array(import_zod6.z.string()),
+  type: SearchUpdateTypeSchema
+});
+var SearchUpdateMessageSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SEARCH_UPDATE"),
+  payload: SearchUpdatePayloadSchema
+});
+var SearchUnsubPayloadSchema = import_zod6.z.object({
+  subscriptionId: import_zod6.z.string()
+});
+var SearchUnsubMessageSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SEARCH_UNSUB"),
+  payload: SearchUnsubPayloadSchema
+});
+
+// src/schemas/cluster-schemas.ts
+var import_zod7 = require("zod");
+var PartitionMapRequestSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("PARTITION_MAP_REQUEST"),
+  payload: import_zod7.z.object({
+    currentVersion: import_zod7.z.number().optional()
+  }).optional()
+});
+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(),
+  queryPredicate: import_zod7.z.any().optional(),
+  querySort: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.enum(["asc", "desc"])).optional()
+});
+var ClusterSubRegisterMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SUB_REGISTER"),
+  payload: ClusterSubRegisterPayloadSchema
+});
+var ClusterSubAckPayloadSchema = import_zod7.z.object({
+  subscriptionId: import_zod7.z.string(),
+  nodeId: import_zod7.z.string(),
+  success: import_zod7.z.boolean(),
+  error: import_zod7.z.string().optional(),
+  initialResults: import_zod7.z.array(import_zod7.z.object({
+    key: import_zod7.z.string(),
+    value: import_zod7.z.unknown(),
+    score: import_zod7.z.number().optional(),
+    matchedTerms: import_zod7.z.array(import_zod7.z.string()).optional()
+  })).optional(),
+  totalHits: import_zod7.z.number().int().nonnegative().optional()
+});
+var ClusterSubAckMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SUB_ACK"),
+  payload: ClusterSubAckPayloadSchema
+});
+var ClusterSubUpdatePayloadSchema = import_zod7.z.object({
+  subscriptionId: import_zod7.z.string(),
+  sourceNodeId: import_zod7.z.string(),
+  key: import_zod7.z.string(),
+  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"]),
+  timestamp: import_zod7.z.number()
+});
+var ClusterSubUpdateMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SUB_UPDATE"),
+  payload: ClusterSubUpdatePayloadSchema
+});
+var ClusterSubUnregisterPayloadSchema = import_zod7.z.object({
+  subscriptionId: import_zod7.z.string()
+});
+var ClusterSubUnregisterMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SUB_UNREGISTER"),
+  payload: ClusterSubUnregisterPayloadSchema
+});
+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({
+    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()
+  }),
+  timeoutMs: import_zod7.z.number().int().positive().optional()
+});
+var ClusterSearchReqMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SEARCH_REQ"),
+  payload: ClusterSearchReqPayloadSchema
+});
+var ClusterSearchRespPayloadSchema = import_zod7.z.object({
+  requestId: import_zod7.z.string(),
+  nodeId: import_zod7.z.string(),
+  results: import_zod7.z.array(import_zod7.z.object({
+    key: import_zod7.z.string(),
+    value: import_zod7.z.unknown(),
+    score: import_zod7.z.number(),
+    matchedTerms: import_zod7.z.array(import_zod7.z.string()).optional()
+  })),
+  totalHits: import_zod7.z.number().int().nonnegative(),
+  executionTimeMs: import_zod7.z.number().nonnegative(),
+  error: import_zod7.z.string().optional()
+});
+var ClusterSearchRespMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SEARCH_RESP"),
+  payload: ClusterSearchRespPayloadSchema
+});
+var ClusterSearchSubscribePayloadSchema = import_zod7.z.object({
+  subscriptionId: import_zod7.z.string(),
+  mapName: import_zod7.z.string(),
+  query: import_zod7.z.string(),
+  options: SearchOptionsSchema.optional()
+});
+var ClusterSearchSubscribeMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SEARCH_SUBSCRIBE"),
+  payload: ClusterSearchSubscribePayloadSchema
+});
+var ClusterSearchUnsubscribePayloadSchema = import_zod7.z.object({
+  subscriptionId: import_zod7.z.string()
+});
+var ClusterSearchUnsubscribeMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SEARCH_UNSUBSCRIBE"),
+  payload: ClusterSearchUnsubscribePayloadSchema
+});
+var ClusterSearchUpdatePayloadSchema = import_zod7.z.object({
+  subscriptionId: import_zod7.z.string(),
+  nodeId: import_zod7.z.string(),
+  key: import_zod7.z.string(),
+  value: import_zod7.z.unknown(),
+  score: import_zod7.z.number(),
+  matchedTerms: import_zod7.z.array(import_zod7.z.string()).optional(),
+  type: SearchUpdateTypeSchema
+});
+var ClusterSearchUpdateMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SEARCH_UPDATE"),
+  payload: ClusterSearchUpdatePayloadSchema
+});
+
+// src/schemas/messaging-schemas.ts
+var import_zod8 = require("zod");
+var TopicSubSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("TOPIC_SUB"),
+  payload: import_zod8.z.object({ topic: import_zod8.z.string() })
+});
+var TopicUnsubSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("TOPIC_UNSUB"),
+  payload: import_zod8.z.object({ topic: import_zod8.z.string() })
+});
+var TopicPubSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("TOPIC_PUB"),
+  payload: import_zod8.z.object({
+    topic: import_zod8.z.string(),
+    data: import_zod8.z.any()
   })
 });
-var ORMapSyncRespBucketsSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ORMAP_SYNC_RESP_BUCKETS"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    path: import_zod3.z.string(),
-    buckets: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number())
+var TopicMessageEventSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("TOPIC_MESSAGE"),
+  payload: import_zod8.z.object({
+    topic: import_zod8.z.string(),
+    data: import_zod8.z.any(),
+    publisherId: import_zod8.z.string().optional(),
+    timestamp: import_zod8.z.number()
   })
 });
-var ORMapMerkleReqBucketSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ORMAP_MERKLE_REQ_BUCKET"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    path: import_zod3.z.string()
+var LockRequestSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("LOCK_REQUEST"),
+  payload: import_zod8.z.object({
+    requestId: import_zod8.z.string(),
+    name: import_zod8.z.string(),
+    ttl: import_zod8.z.number().optional()
   })
 });
-var ORMapSyncRespLeafSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ORMAP_SYNC_RESP_LEAF"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    path: import_zod3.z.string(),
-    entries: import_zod3.z.array(import_zod3.z.object({
-      key: import_zod3.z.string(),
-      records: import_zod3.z.array(ORMapRecordSchema),
-      tombstones: import_zod3.z.array(import_zod3.z.string())
-      // Tombstone tags for this key's records
-    }))
+var LockReleaseSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("LOCK_RELEASE"),
+  payload: import_zod8.z.object({
+    requestId: import_zod8.z.string().optional(),
+    name: import_zod8.z.string(),
+    fencingToken: import_zod8.z.number()
   })
 });
-var ORMapDiffRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ORMAP_DIFF_REQUEST"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    keys: import_zod3.z.array(import_zod3.z.string())
+var PNCounterStateObjectSchema = import_zod8.z.object({
+  p: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.number()),
+  n: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.number())
+});
+var CounterRequestSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("COUNTER_REQUEST"),
+  payload: import_zod8.z.object({ name: import_zod8.z.string() })
+});
+var CounterSyncSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("COUNTER_SYNC"),
+  payload: import_zod8.z.object({
+    name: import_zod8.z.string(),
+    state: PNCounterStateObjectSchema
   })
 });
-var ORMapDiffResponseSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ORMAP_DIFF_RESPONSE"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    entries: import_zod3.z.array(import_zod3.z.object({
-      key: import_zod3.z.string(),
-      records: import_zod3.z.array(ORMapRecordSchema),
-      tombstones: import_zod3.z.array(import_zod3.z.string())
-    }))
+var CounterResponseSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("COUNTER_RESPONSE"),
+  payload: import_zod8.z.object({
+    name: import_zod8.z.string(),
+    state: PNCounterStateObjectSchema
   })
 });
-var ORMapPushDiffSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ORMAP_PUSH_DIFF"),
-  payload: import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    entries: import_zod3.z.array(import_zod3.z.object({
-      key: import_zod3.z.string(),
-      records: import_zod3.z.array(ORMapRecordSchema),
-      tombstones: import_zod3.z.array(import_zod3.z.string())
-    }))
+var CounterUpdateSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("COUNTER_UPDATE"),
+  payload: import_zod8.z.object({
+    name: import_zod8.z.string(),
+    state: PNCounterStateObjectSchema
   })
 });
-var PartitionMapRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("PARTITION_MAP_REQUEST"),
-  payload: import_zod3.z.object({
-    currentVersion: import_zod3.z.number().optional()
-  }).optional()
+var PingMessageSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("PING"),
+  timestamp: import_zod8.z.number()
 });
-var EntryProcessorSchema = import_zod3.z.object({
-  name: import_zod3.z.string().min(1).max(100),
-  code: import_zod3.z.string().min(1).max(1e4),
-  args: import_zod3.z.unknown().optional()
+var PongMessageSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("PONG"),
+  timestamp: import_zod8.z.number(),
+  serverTime: import_zod8.z.number()
 });
-var EntryProcessRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ENTRY_PROCESS"),
-  requestId: import_zod3.z.string(),
-  mapName: import_zod3.z.string(),
-  key: import_zod3.z.string(),
+var EntryProcessorSchema = import_zod8.z.object({
+  name: import_zod8.z.string().min(1).max(100),
+  code: import_zod8.z.string().min(1).max(1e4),
+  args: import_zod8.z.unknown().optional()
+});
+var EntryProcessRequestSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("ENTRY_PROCESS"),
+  requestId: import_zod8.z.string(),
+  mapName: import_zod8.z.string(),
+  key: import_zod8.z.string(),
   processor: EntryProcessorSchema
 });
-var EntryProcessBatchRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ENTRY_PROCESS_BATCH"),
-  requestId: import_zod3.z.string(),
-  mapName: import_zod3.z.string(),
-  keys: import_zod3.z.array(import_zod3.z.string()),
+var EntryProcessBatchRequestSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("ENTRY_PROCESS_BATCH"),
+  requestId: import_zod8.z.string(),
+  mapName: import_zod8.z.string(),
+  keys: import_zod8.z.array(import_zod8.z.string()),
   processor: EntryProcessorSchema
 });
-var EntryProcessResponseSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ENTRY_PROCESS_RESPONSE"),
-  requestId: import_zod3.z.string(),
-  success: import_zod3.z.boolean(),
-  result: import_zod3.z.unknown().optional(),
-  newValue: import_zod3.z.unknown().optional(),
-  error: import_zod3.z.string().optional()
+var EntryProcessResponseSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("ENTRY_PROCESS_RESPONSE"),
+  requestId: import_zod8.z.string(),
+  success: import_zod8.z.boolean(),
+  result: import_zod8.z.unknown().optional(),
+  newValue: import_zod8.z.unknown().optional(),
+  error: import_zod8.z.string().optional()
 });
-var EntryProcessKeyResultSchema = import_zod3.z.object({
-  success: import_zod3.z.boolean(),
-  result: import_zod3.z.unknown().optional(),
-  newValue: import_zod3.z.unknown().optional(),
-  error: import_zod3.z.string().optional()
+var EntryProcessKeyResultSchema = import_zod8.z.object({
+  success: import_zod8.z.boolean(),
+  result: import_zod8.z.unknown().optional(),
+  newValue: import_zod8.z.unknown().optional(),
+  error: import_zod8.z.string().optional()
 });
-var EntryProcessBatchResponseSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("ENTRY_PROCESS_BATCH_RESPONSE"),
-  requestId: import_zod3.z.string(),
-  results: import_zod3.z.record(import_zod3.z.string(), EntryProcessKeyResultSchema)
+var EntryProcessBatchResponseSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("ENTRY_PROCESS_BATCH_RESPONSE"),
+  requestId: import_zod8.z.string(),
+  results: import_zod8.z.record(import_zod8.z.string(), EntryProcessKeyResultSchema)
 });
-var JournalEventTypeSchema = import_zod3.z.enum(["PUT", "UPDATE", "DELETE"]);
-var JournalEventDataSchema = import_zod3.z.object({
-  sequence: import_zod3.z.string(),
-  // bigint as string
+var JournalEventTypeSchema = import_zod8.z.enum(["PUT", "UPDATE", "DELETE"]);
+var JournalEventDataSchema = import_zod8.z.object({
+  sequence: import_zod8.z.string(),
   type: JournalEventTypeSchema,
-  mapName: import_zod3.z.string(),
-  key: import_zod3.z.string(),
-  value: import_zod3.z.unknown().optional(),
-  previousValue: import_zod3.z.unknown().optional(),
+  mapName: import_zod8.z.string(),
+  key: import_zod8.z.string(),
+  value: import_zod8.z.unknown().optional(),
+  previousValue: import_zod8.z.unknown().optional(),
   timestamp: TimestampSchema,
-  nodeId: import_zod3.z.string(),
-  metadata: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  nodeId: import_zod8.z.string(),
+  metadata: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).optional()
 });
-var JournalSubscribeRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("JOURNAL_SUBSCRIBE"),
-  requestId: import_zod3.z.string(),
-  fromSequence: import_zod3.z.string().optional(),
-  // bigint as string
-  mapName: import_zod3.z.string().optional(),
-  types: import_zod3.z.array(JournalEventTypeSchema).optional()
+var JournalSubscribeRequestSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("JOURNAL_SUBSCRIBE"),
+  requestId: import_zod8.z.string(),
+  fromSequence: import_zod8.z.string().optional(),
+  mapName: import_zod8.z.string().optional(),
+  types: import_zod8.z.array(JournalEventTypeSchema).optional()
 });
-var JournalUnsubscribeRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("JOURNAL_UNSUBSCRIBE"),
-  subscriptionId: import_zod3.z.string()
+var JournalUnsubscribeRequestSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("JOURNAL_UNSUBSCRIBE"),
+  subscriptionId: import_zod8.z.string()
 });
-var JournalEventMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("JOURNAL_EVENT"),
+var JournalEventMessageSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("JOURNAL_EVENT"),
   event: JournalEventDataSchema
 });
-var JournalReadRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("JOURNAL_READ"),
-  requestId: import_zod3.z.string(),
-  fromSequence: import_zod3.z.string(),
-  limit: import_zod3.z.number().optional(),
-  mapName: import_zod3.z.string().optional()
+var JournalReadRequestSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("JOURNAL_READ"),
+  requestId: import_zod8.z.string(),
+  fromSequence: import_zod8.z.string(),
+  limit: import_zod8.z.number().optional(),
+  mapName: import_zod8.z.string().optional()
 });
-var JournalReadResponseSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("JOURNAL_READ_RESPONSE"),
-  requestId: import_zod3.z.string(),
-  events: import_zod3.z.array(JournalEventDataSchema),
-  hasMore: import_zod3.z.boolean()
+var JournalReadResponseSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("JOURNAL_READ_RESPONSE"),
+  requestId: import_zod8.z.string(),
+  events: import_zod8.z.array(JournalEventDataSchema),
+  hasMore: import_zod8.z.boolean()
 });
-var SearchOptionsSchema = import_zod3.z.object({
-  limit: import_zod3.z.number().optional(),
-  minScore: import_zod3.z.number().optional(),
-  boost: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()).optional()
+var ConflictResolverSchema = import_zod8.z.object({
+  name: import_zod8.z.string().min(1).max(100),
+  code: import_zod8.z.string().max(5e4),
+  priority: import_zod8.z.number().int().min(0).max(100).optional(),
+  keyPattern: import_zod8.z.string().optional()
 });
-var SearchPayloadSchema = import_zod3.z.object({
-  requestId: import_zod3.z.string(),
-  mapName: import_zod3.z.string(),
-  query: import_zod3.z.string(),
-  options: SearchOptionsSchema.optional()
+var RegisterResolverRequestSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("REGISTER_RESOLVER"),
+  requestId: import_zod8.z.string(),
+  mapName: import_zod8.z.string(),
+  resolver: ConflictResolverSchema
 });
-var SearchMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SEARCH"),
-  payload: SearchPayloadSchema
+var RegisterResolverResponseSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("REGISTER_RESOLVER_RESPONSE"),
+  requestId: import_zod8.z.string(),
+  success: import_zod8.z.boolean(),
+  error: import_zod8.z.string().optional()
 });
-var SearchRespPayloadSchema = import_zod3.z.object({
-  requestId: import_zod3.z.string(),
-  results: import_zod3.z.array(import_zod3.z.object({
-    key: import_zod3.z.string(),
-    value: import_zod3.z.unknown(),
-    score: import_zod3.z.number(),
-    matchedTerms: import_zod3.z.array(import_zod3.z.string())
-  })),
-  totalCount: import_zod3.z.number(),
-  error: import_zod3.z.string().optional()
+var UnregisterResolverRequestSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("UNREGISTER_RESOLVER"),
+  requestId: import_zod8.z.string(),
+  mapName: import_zod8.z.string(),
+  resolverName: import_zod8.z.string()
 });
-var SearchRespMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SEARCH_RESP"),
-  payload: SearchRespPayloadSchema
+var UnregisterResolverResponseSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("UNREGISTER_RESOLVER_RESPONSE"),
+  requestId: import_zod8.z.string(),
+  success: import_zod8.z.boolean(),
+  error: import_zod8.z.string().optional()
 });
-var SearchUpdateTypeSchema = import_zod3.z.enum(["ENTER", "UPDATE", "LEAVE"]);
-var SearchSubPayloadSchema = import_zod3.z.object({
-  subscriptionId: import_zod3.z.string(),
-  mapName: import_zod3.z.string(),
-  query: import_zod3.z.string(),
-  options: SearchOptionsSchema.optional()
+var MergeRejectedMessageSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("MERGE_REJECTED"),
+  mapName: import_zod8.z.string(),
+  key: import_zod8.z.string(),
+  attemptedValue: import_zod8.z.unknown(),
+  reason: import_zod8.z.string(),
+  timestamp: TimestampSchema
 });
-var SearchSubMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SEARCH_SUB"),
-  payload: SearchSubPayloadSchema
+var ListResolversRequestSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("LIST_RESOLVERS"),
+  requestId: import_zod8.z.string(),
+  mapName: import_zod8.z.string().optional()
 });
-var SearchUpdatePayloadSchema = import_zod3.z.object({
-  subscriptionId: import_zod3.z.string(),
-  key: import_zod3.z.string(),
-  value: import_zod3.z.unknown(),
-  score: import_zod3.z.number(),
-  matchedTerms: import_zod3.z.array(import_zod3.z.string()),
-  type: SearchUpdateTypeSchema
+var ListResolversResponseSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("LIST_RESOLVERS_RESPONSE"),
+  requestId: import_zod8.z.string(),
+  resolvers: import_zod8.z.array(import_zod8.z.object({
+    mapName: import_zod8.z.string(),
+    name: import_zod8.z.string(),
+    priority: import_zod8.z.number().optional(),
+    keyPattern: import_zod8.z.string().optional()
+  }))
 });
-var SearchUpdateMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SEARCH_UPDATE"),
-  payload: SearchUpdatePayloadSchema
+
+// src/schemas/client-message-schemas.ts
+var import_zod9 = require("zod");
+var ServerEventPayloadSchema = import_zod9.z.object({
+  mapName: import_zod9.z.string(),
+  eventType: import_zod9.z.enum(["PUT", "REMOVE", "OR_ADD", "OR_REMOVE"]),
+  key: import_zod9.z.string(),
+  record: LWWRecordSchema.optional(),
+  orRecord: ORMapRecordSchema.optional(),
+  orTag: import_zod9.z.string().optional()
 });
-var SearchUnsubPayloadSchema = import_zod3.z.object({
-  subscriptionId: import_zod3.z.string()
+var ServerEventMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("SERVER_EVENT"),
+  payload: ServerEventPayloadSchema
 });
-var SearchUnsubMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SEARCH_UNSUB"),
-  payload: SearchUnsubPayloadSchema
+var ServerBatchEventMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("SERVER_BATCH_EVENT"),
+  payload: import_zod9.z.object({
+    events: import_zod9.z.array(ServerEventPayloadSchema)
+  })
 });
-var ConflictResolverSchema = import_zod3.z.object({
-  name: import_zod3.z.string().min(1).max(100),
-  code: import_zod3.z.string().max(5e4),
-  priority: import_zod3.z.number().int().min(0).max(100).optional(),
-  keyPattern: import_zod3.z.string().optional()
+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"])
 });
-var RegisterResolverRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("REGISTER_RESOLVER"),
-  requestId: import_zod3.z.string(),
-  mapName: import_zod3.z.string(),
-  resolver: ConflictResolverSchema
+var QueryUpdateMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("QUERY_UPDATE"),
+  payload: QueryUpdatePayloadSchema
 });
-var RegisterResolverResponseSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("REGISTER_RESOLVER_RESPONSE"),
-  requestId: import_zod3.z.string(),
-  success: import_zod3.z.boolean(),
-  error: import_zod3.z.string().optional()
+var GcPrunePayloadSchema = import_zod9.z.object({
+  olderThan: TimestampSchema
 });
-var UnregisterResolverRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("UNREGISTER_RESOLVER"),
-  requestId: import_zod3.z.string(),
-  mapName: import_zod3.z.string(),
-  resolverName: import_zod3.z.string()
+var GcPruneMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("GC_PRUNE"),
+  payload: GcPrunePayloadSchema
 });
-var UnregisterResolverResponseSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("UNREGISTER_RESOLVER_RESPONSE"),
-  requestId: import_zod3.z.string(),
-  success: import_zod3.z.boolean(),
-  error: import_zod3.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 MergeRejectedMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("MERGE_REJECTED"),
-  mapName: import_zod3.z.string(),
-  key: import_zod3.z.string(),
-  attemptedValue: import_zod3.z.unknown(),
-  reason: import_zod3.z.string(),
-  timestamp: TimestampSchema
+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 ListResolversRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("LIST_RESOLVERS"),
-  requestId: import_zod3.z.string(),
-  mapName: import_zod3.z.string().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 ListResolversResponseSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("LIST_RESOLVERS_RESPONSE"),
-  requestId: import_zod3.z.string(),
-  resolvers: import_zod3.z.array(import_zod3.z.object({
-    mapName: import_zod3.z.string(),
-    name: import_zod3.z.string(),
-    priority: import_zod3.z.number().optional(),
-    keyPattern: import_zod3.z.string().optional()
-  }))
+var LockGrantedPayloadSchema = import_zod9.z.object({
+  requestId: import_zod9.z.string(),
+  fencingToken: import_zod9.z.number()
 });
-var OpResultSchema = import_zod3.z.object({
-  opId: import_zod3.z.string(),
-  success: import_zod3.z.boolean(),
-  achievedLevel: WriteConcernSchema,
-  error: import_zod3.z.string().optional()
+var LockReleasedPayloadSchema = import_zod9.z.object({
+  requestId: import_zod9.z.string(),
+  success: import_zod9.z.boolean()
 });
-var OpAckMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("OP_ACK"),
-  payload: import_zod3.z.object({
-    /** ID of the last operation in the batch (for backwards compatibility) */
-    lastId: import_zod3.z.string(),
-    /** Write Concern level achieved (for simple ACKs) */
-    achievedLevel: WriteConcernSchema.optional(),
-    /** Per-operation results (for batch operations with mixed Write Concern) */
-    results: import_zod3.z.array(OpResultSchema).optional()
-  })
+var SyncResetRequiredPayloadSchema = import_zod9.z.object({
+  mapName: import_zod9.z.string(),
+  reason: import_zod9.z.string()
 });
-var OpRejectedMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("OP_REJECTED"),
-  payload: import_zod3.z.object({
-    /** Operation ID that was rejected */
-    opId: import_zod3.z.string(),
-    /** Reason for rejection */
-    reason: import_zod3.z.string(),
-    /** Error code */
-    code: import_zod3.z.number().optional()
-  })
+
+// src/schemas/http-sync-schemas.ts
+var import_zod10 = require("zod");
+var SyncMapEntrySchema = import_zod10.z.object({
+  mapName: import_zod10.z.string(),
+  lastSyncTimestamp: TimestampSchema
 });
-var ClusterSubRegisterPayloadSchema = import_zod3.z.object({
-  /** Unique subscription ID */
-  subscriptionId: import_zod3.z.string(),
-  /** Node ID of the coordinator (receives updates) */
-  coordinatorNodeId: import_zod3.z.string(),
-  /** Map name to subscribe to */
-  mapName: import_zod3.z.string(),
-  /** Subscription type */
-  type: import_zod3.z.enum(["SEARCH", "QUERY"]),
-  // For FTS subscriptions
-  /** Search query string (for SEARCH type) */
-  searchQuery: import_zod3.z.string().optional(),
-  /** Search options (for SEARCH type) */
-  searchOptions: import_zod3.z.object({
-    limit: import_zod3.z.number().int().positive().optional(),
-    minScore: import_zod3.z.number().optional(),
-    boost: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()).optional()
-  }).optional(),
-  // For Query subscriptions
-  /** Query predicate (for QUERY type) */
-  queryPredicate: import_zod3.z.any().optional(),
-  /** Query sort order (for QUERY type) */
-  querySort: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.enum(["asc", "desc"])).optional()
+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 ClusterSubRegisterMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SUB_REGISTER"),
-  payload: ClusterSubRegisterPayloadSchema
+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 ClusterSubAckPayloadSchema = import_zod3.z.object({
-  /** Correlates to subscriptionId */
-  subscriptionId: import_zod3.z.string(),
-  /** Node that registered this subscription */
-  nodeId: import_zod3.z.string(),
-  /** Registration success status */
-  success: import_zod3.z.boolean(),
-  /** Error message if failed */
-  error: import_zod3.z.string().optional(),
-  /** Initial results from this node */
-  initialResults: import_zod3.z.array(import_zod3.z.object({
-    key: import_zod3.z.string(),
-    value: import_zod3.z.unknown(),
-    score: import_zod3.z.number().optional(),
-    matchedTerms: import_zod3.z.array(import_zod3.z.string()).optional()
-  })).optional(),
-  /** Total matching documents on this node */
-  totalHits: import_zod3.z.number().int().nonnegative().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 ClusterSubAckMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SUB_ACK"),
-  payload: ClusterSubAckPayloadSchema
+var DeltaRecordSchema = import_zod10.z.object({
+  key: import_zod10.z.string(),
+  record: LWWRecordSchema,
+  eventType: import_zod10.z.enum(["PUT", "REMOVE"])
 });
-var ClusterSubUpdatePayloadSchema = import_zod3.z.object({
-  /** Subscription ID this update belongs to */
-  subscriptionId: import_zod3.z.string(),
-  /** Node that produced this update */
-  sourceNodeId: import_zod3.z.string(),
-  /** Document key */
-  key: import_zod3.z.string(),
-  /** Document value (null for LEAVE) */
-  value: import_zod3.z.unknown(),
-  /** Search score (for SEARCH type) */
-  score: import_zod3.z.number().optional(),
-  /** Matched terms (for SEARCH type) */
-  matchedTerms: import_zod3.z.array(import_zod3.z.string()).optional(),
-  /** Change type: ENTER (new match), UPDATE (still matches), LEAVE (no longer matches) */
-  changeType: import_zod3.z.enum(["ENTER", "UPDATE", "LEAVE"]),
-  /** Timestamp for ordering */
-  timestamp: import_zod3.z.number()
+var MapDeltaSchema = import_zod10.z.object({
+  mapName: import_zod10.z.string(),
+  records: import_zod10.z.array(DeltaRecordSchema),
+  serverSyncTimestamp: TimestampSchema
 });
-var ClusterSubUpdateMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SUB_UPDATE"),
-  payload: ClusterSubUpdatePayloadSchema
+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 ClusterSubUnregisterPayloadSchema = import_zod3.z.object({
-  /** Subscription ID to remove */
-  subscriptionId: import_zod3.z.string()
+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 ClusterSubUnregisterMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SUB_UNREGISTER"),
-  payload: ClusterSubUnregisterPayloadSchema
+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()
 });
-var MessageSchema = import_zod3.z.discriminatedUnion("type", [
+
+// src/schemas/index.ts
+var import_zod11 = require("zod");
+var MessageSchema = import_zod11.z.discriminatedUnion("type", [
   AuthMessageSchema,
   QuerySubMessageSchema,
   QueryUnsubMessageSchema,
@@ -3002,7 +3258,6 @@ var MessageSchema = import_zod3.z.discriminatedUnion("type", [
   TopicPubSchema,
   PingMessageSchema,
   PongMessageSchema,
-  // ORMap Sync Messages
   ORMapSyncInitSchema,
   ORMapSyncRespRootSchema,
   ORMapSyncRespBucketsSchema,
@@ -3011,23 +3266,18 @@ var MessageSchema = import_zod3.z.discriminatedUnion("type", [
   ORMapDiffRequestSchema,
   ORMapDiffResponseSchema,
   ORMapPushDiffSchema,
-  // Phase 4: Partition Map
   PartitionMapRequestSchema,
-  // Phase 5.2: PN Counter
   CounterRequestSchema,
   CounterSyncSchema,
-  // Phase 5.03: Entry Processor
   EntryProcessRequestSchema,
   EntryProcessBatchRequestSchema,
   EntryProcessResponseSchema,
   EntryProcessBatchResponseSchema,
-  // Phase 5.04: Event Journal
   JournalSubscribeRequestSchema,
   JournalUnsubscribeRequestSchema,
   JournalEventMessageSchema,
   JournalReadRequestSchema,
   JournalReadResponseSchema,
-  // Phase 5.05: Conflict Resolver
   RegisterResolverRequestSchema,
   RegisterResolverResponseSchema,
   UnregisterResolverRequestSchema,
@@ -3035,101 +3285,16 @@ var MessageSchema = import_zod3.z.discriminatedUnion("type", [
   MergeRejectedMessageSchema,
   ListResolversRequestSchema,
   ListResolversResponseSchema,
-  // Phase 11.1: Full-Text Search
   SearchMessageSchema,
   SearchRespMessageSchema,
-  // Phase 11.1b: Live Search Subscriptions
   SearchSubMessageSchema,
   SearchUpdateMessageSchema,
   SearchUnsubMessageSchema,
-  // Phase 14.2: Distributed Live Subscriptions (cluster-internal)
   ClusterSubRegisterMessageSchema,
   ClusterSubAckMessageSchema,
   ClusterSubUpdateMessageSchema,
   ClusterSubUnregisterMessageSchema
 ]);
-var ClusterSearchReqPayloadSchema = import_zod3.z.object({
-  /** Unique request ID for correlation */
-  requestId: import_zod3.z.string(),
-  /** Map name to search */
-  mapName: import_zod3.z.string(),
-  /** Search query text */
-  query: import_zod3.z.string(),
-  /** Search options */
-  options: import_zod3.z.object({
-    /** Maximum results per node (for Top-K) */
-    limit: import_zod3.z.number().int().positive().max(1e3),
-    /** Minimum score threshold */
-    minScore: import_zod3.z.number().optional(),
-    /** Fields to boost */
-    boost: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()).optional(),
-    /** Include matched terms in response */
-    includeMatchedTerms: import_zod3.z.boolean().optional(),
-    /** For cursor-based pagination: return results after this score */
-    afterScore: import_zod3.z.number().optional(),
-    /** For cursor-based pagination: return results after this key (tie-breaking) */
-    afterKey: import_zod3.z.string().optional()
-  }),
-  /** Timeout in milliseconds */
-  timeoutMs: import_zod3.z.number().int().positive().optional()
-});
-var ClusterSearchReqMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SEARCH_REQ"),
-  payload: ClusterSearchReqPayloadSchema
-});
-var ClusterSearchRespPayloadSchema = import_zod3.z.object({
-  /** Correlates to requestId */
-  requestId: import_zod3.z.string(),
-  /** Node that produced these results */
-  nodeId: import_zod3.z.string(),
-  /** Search results with scores */
-  results: import_zod3.z.array(import_zod3.z.object({
-    key: import_zod3.z.string(),
-    value: import_zod3.z.unknown(),
-    score: import_zod3.z.number(),
-    matchedTerms: import_zod3.z.array(import_zod3.z.string()).optional()
-  })),
-  /** Total matching documents on this node (for pagination) */
-  totalHits: import_zod3.z.number().int().nonnegative(),
-  /** Execution time on this node in ms (for monitoring) */
-  executionTimeMs: import_zod3.z.number().nonnegative(),
-  /** Error if search failed on this node */
-  error: import_zod3.z.string().optional()
-});
-var ClusterSearchRespMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SEARCH_RESP"),
-  payload: ClusterSearchRespPayloadSchema
-});
-var ClusterSearchSubscribePayloadSchema = import_zod3.z.object({
-  subscriptionId: import_zod3.z.string(),
-  mapName: import_zod3.z.string(),
-  query: import_zod3.z.string(),
-  options: SearchOptionsSchema.optional()
-});
-var ClusterSearchSubscribeMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SEARCH_SUBSCRIBE"),
-  payload: ClusterSearchSubscribePayloadSchema
-});
-var ClusterSearchUnsubscribePayloadSchema = import_zod3.z.object({
-  subscriptionId: import_zod3.z.string()
-});
-var ClusterSearchUnsubscribeMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SEARCH_UNSUBSCRIBE"),
-  payload: ClusterSearchUnsubscribePayloadSchema
-});
-var ClusterSearchUpdatePayloadSchema = import_zod3.z.object({
-  subscriptionId: import_zod3.z.string(),
-  nodeId: import_zod3.z.string(),
-  key: import_zod3.z.string(),
-  value: import_zod3.z.unknown(),
-  score: import_zod3.z.number(),
-  matchedTerms: import_zod3.z.array(import_zod3.z.string()).optional(),
-  type: SearchUpdateTypeSchema
-});
-var ClusterSearchUpdateMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SEARCH_UPDATE"),
-  payload: ClusterSearchUpdatePayloadSchema
-});
 
 // src/types/WriteConcern.ts
 var WriteConcern = /* @__PURE__ */ ((WriteConcern2) => {
@@ -4088,6 +4253,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",
@@ -6054,7 +6231,7 @@ var IndexRegistry = class {
   constructor() {
     /** Indexes grouped by attribute name */
     this.attributeIndexes = /* @__PURE__ */ new Map();
-    /** Compound indexes (Phase 9.03) - keyed by sorted attribute names */
+    /** Compound indexes - keyed by sorted attribute names */
     this.compoundIndexes = /* @__PURE__ */ new Map();
     /** Fallback index for full scan (optional) */
     this.fallbackIndex = null;
@@ -6081,7 +6258,7 @@ var IndexRegistry = class {
     }
   }
   /**
-   * Register a compound index (Phase 9.03).
+   * Register a compound index.
    *
    * @param index - Compound index to register
    */
@@ -6115,7 +6292,7 @@ var IndexRegistry = class {
     return true;
   }
   /**
-   * Remove a compound index (Phase 9.03).
+   * Remove a compound index.
    *
    * @param index - Compound index to remove
    * @returns true if index was found and removed
@@ -6195,10 +6372,10 @@ var IndexRegistry = class {
     return indexes.filter((index) => index.supportsQuery(queryType)).sort((a, b) => a.getRetrievalCost() - b.getRetrievalCost());
   }
   // ========================================
-  // Phase 9.03: Compound Index Methods
+  // Compound Index Methods
   // ========================================
   /**
-   * Find a compound index that covers the given attribute names (Phase 9.03).
+   * Find a compound index that covers the given attribute names.
    * The compound index must cover ALL the attributes (exact match or superset).
    *
    * @param attributeNames - Array of attribute names to search for
@@ -6216,7 +6393,7 @@ var IndexRegistry = class {
     return null;
   }
   /**
-   * Check if a compound index exists for the given attributes (Phase 9.03).
+   * Check if a compound index exists for the given attributes.
    *
    * @param attributeNames - Array of attribute names
    * @returns true if a compound index exists
@@ -6225,7 +6402,7 @@ var IndexRegistry = class {
     return this.findCompoundIndex(attributeNames) !== null;
   }
   /**
-   * Get all compound indexes (Phase 9.03).
+   * Get all compound indexes.
    *
    * @returns Array of all compound indexes
    */
@@ -6363,22 +6540,15 @@ var QueryOptimizer = class {
   /**
    * Create a QueryOptimizer.
    *
-   * @param indexRegistryOrOptions - IndexRegistry or options object
-   * @param standingQueryRegistry - Optional StandingQueryRegistry (deprecated, use options)
+   * @param options - QueryOptimizer options
    */
-  constructor(indexRegistryOrOptions, standingQueryRegistry) {
-    if ("indexRegistry" in indexRegistryOrOptions) {
-      this.indexRegistry = indexRegistryOrOptions.indexRegistry;
-      this.standingQueryRegistry = indexRegistryOrOptions.standingQueryRegistry;
-      this.fullTextIndexes = indexRegistryOrOptions.fullTextIndexes ?? /* @__PURE__ */ new Map();
-    } else {
-      this.indexRegistry = indexRegistryOrOptions;
-      this.standingQueryRegistry = standingQueryRegistry;
-      this.fullTextIndexes = /* @__PURE__ */ new Map();
-    }
+  constructor(options) {
+    this.indexRegistry = options.indexRegistry;
+    this.standingQueryRegistry = options.standingQueryRegistry;
+    this.fullTextIndexes = options.fullTextIndexes ?? /* @__PURE__ */ new Map();
   }
   /**
-   * Register a full-text index for a field (Phase 12).
+   * Register a full-text index for a field.
    *
    * @param field - Field name
    * @param index - FullTextIndex instance
@@ -6387,7 +6557,7 @@ var QueryOptimizer = class {
     this.fullTextIndexes.set(field, index);
   }
   /**
-   * Unregister a full-text index (Phase 12).
+   * Unregister a full-text index.
    *
    * @param field - Field name
    */
@@ -6395,7 +6565,7 @@ var QueryOptimizer = class {
     this.fullTextIndexes.delete(field);
   }
   /**
-   * Get registered full-text index for a field (Phase 12).
+   * Get registered full-text index for a field.
    *
    * @param field - Field name
    * @returns FullTextIndex or undefined
@@ -6404,7 +6574,7 @@ var QueryOptimizer = class {
     return this.fullTextIndexes.get(field);
   }
   /**
-   * Check if a full-text index exists for a field (Phase 12).
+   * Check if a full-text index exists for a field.
    *
    * @param field - Field name
    * @returns True if FTS index exists
@@ -6416,13 +6586,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) {
@@ -6446,16 +6625,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;
@@ -6472,14 +6703,73 @@ var QueryOptimizer = class {
       }
     }
     return {
-      ...basePlan,
+      ...plan,
       indexedSort,
       sort: sortField && sortDirection ? { field: sortField, direction: sortDirection } : void 0,
       limit: options.limit,
       cursor: options.cursor
-      // Phase 14.1: 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.
    */
@@ -6495,7 +6785,7 @@ var QueryOptimizer = class {
     }
   }
   /**
-   * Optimize a full-text search query (Phase 12).
+   * Optimize a full-text search query.
    */
   optimizeFTS(query) {
     const field = query.attribute;
@@ -6505,7 +6795,7 @@ var QueryOptimizer = class {
     return this.buildFTSScanStep(query);
   }
   /**
-   * Build an FTS scan step from a query node (Phase 12).
+   * Build an FTS scan step from a query node.
    */
   buildFTSScanStep(query) {
     const field = query.attribute;
@@ -6545,7 +6835,7 @@ var QueryOptimizer = class {
     }
   }
   /**
-   * Estimate cost of FTS query based on index size (Phase 12).
+   * Estimate cost of FTS query based on index size.
    */
   estimateFTSCost(field) {
     const index = this.fullTextIndexes.get(field);
@@ -6556,7 +6846,7 @@ var QueryOptimizer = class {
     return 50 + Math.log2(docCount + 1) * 10;
   }
   /**
-   * Classify predicates by type for hybrid query planning (Phase 12).
+   * Classify predicates by type for hybrid query planning.
    *
    * @param predicates - Array of predicates to classify
    * @returns Classified predicates
@@ -6597,7 +6887,7 @@ var QueryOptimizer = class {
     return result;
   }
   /**
-   * Determine fusion strategy based on step types (Phase 12).
+   * Determine fusion strategy based on step types.
    *
    * Strategy selection:
    * - All binary (exact/range with no scores) → 'intersection'
@@ -6619,7 +6909,7 @@ var QueryOptimizer = class {
     }
   }
   /**
-   * Check if a plan step returns scored results (Phase 12).
+   * Check if a plan step returns scored results.
    */
   stepReturnsScored(step) {
     switch (step.type) {
@@ -6663,7 +6953,7 @@ var QueryOptimizer = class {
    * Strategy: Find child with lowest cost, use as base, filter with rest.
    *
    * CQEngine "smallest first" strategy:
-   * 1. Check for CompoundIndex covering all eq children (Phase 9.03)
+   * 1. Check for CompoundIndex covering all eq children
    * 2. Sort children by merge cost
    * 3. Use intersection if multiple indexes available
    * 4. Apply remaining predicates as filters
@@ -6704,7 +6994,7 @@ var QueryOptimizer = class {
     return { type: "intersection", steps: indexedSteps };
   }
   /**
-   * Try to use a CompoundIndex for an AND query (Phase 9.03).
+   * Try to use a CompoundIndex for an AND query.
    *
    * Returns a compound index scan step if:
    * 1. All children are simple 'eq' queries
@@ -6868,6 +7158,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":
@@ -6886,7 +7179,7 @@ var QueryOptimizer = class {
         return this.estimateCost(step.source) + 10;
       case "not":
         return this.estimateCost(step.source) + 100;
-      // Phase 12: FTS step types
+      // FTS step types
       case "fts-scan":
         return step.estimatedCost;
       case "fusion":
@@ -6903,22 +7196,100 @@ var QueryOptimizer = class {
     }
   }
   /**
-   * Check if a plan step uses any indexes.
+   * 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
    */
-  usesIndexes(step) {
+  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 "index-scan":
-        return true;
       case "full-scan":
-        return false;
+        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":
-        return step.steps.some((s) => this.usesIndexes(s));
+        networkCost = step.steps.length * 5;
+        break;
       case "filter":
-        return this.usesIndexes(step.source);
+        return this.estimateDistributedCost(step.source, context);
       case "not":
-        return this.usesIndexes(step.source);
-      // Phase 12: FTS step types
+        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":
+        return false;
+      case "intersection":
+      case "union":
+        return step.steps.some((s) => this.usesIndexes(s));
+      case "filter":
+        return this.usesIndexes(step.source);
+      case "not":
+        return this.usesIndexes(step.source);
+      // FTS step types
       case "fts-scan":
         return true;
       // FTS uses FullTextIndex
@@ -7175,7 +7546,7 @@ var LiveQueryManager = class {
         results: initialResults
       });
     } catch (error) {
-      console.error("LiveQueryManager initial callback error:", error);
+      logger.error({ err: error, query, context: "initial_callback" }, "LiveQueryManager initial callback error");
     }
     return () => {
       callbacks?.delete(callback);
@@ -7274,7 +7645,7 @@ var LiveQueryManager = class {
             newResultCount: index.getResultCount()
           });
         } catch (error) {
-          console.error("LiveQueryManager callback error:", error);
+          logger.error({ err: error, operation, context: "delta_callback" }, "LiveQueryManager callback error");
         }
       }
     }
@@ -7409,7 +7780,7 @@ var QueryPatternTracker = class {
     }
   }
   /**
-   * Record a compound (AND) query execution for pattern tracking (Phase 9.03).
+   * Record a compound (AND) query execution for pattern tracking.
    *
    * @param attributes - Array of attribute names being queried together
    * @param executionTime - Query execution time in milliseconds
@@ -7449,7 +7820,7 @@ var QueryPatternTracker = class {
     }
   }
   /**
-   * Get all compound query statistics (Phase 9.03).
+   * Get all compound query statistics.
    *
    * @returns Array of compound query statistics, sorted by query count descending
    */
@@ -7639,7 +8010,7 @@ var QueryPatternTracker = class {
     }
   }
   /**
-   * Evict the oldest compound query entry (Phase 9.03).
+   * Evict the oldest compound query entry.
    */
   evictOldestCompound() {
     let oldestKey = null;
@@ -7655,7 +8026,7 @@ var QueryPatternTracker = class {
     }
   }
   /**
-   * Prune stale compound statistics (Phase 9.03).
+   * Prune stale compound statistics.
    */
   pruneStaleCompound() {
     const cutoff = Date.now() - this.statsTtl;
@@ -7904,7 +8275,7 @@ var IndexAdvisor = class {
     return reason;
   }
   // ========================================
-  // Phase 9.03: Compound Index Suggestions
+  // Compound Index Suggestions
   // ========================================
   /**
    * Get compound index suggestions based on AND query patterns.
@@ -8225,7 +8596,7 @@ var AutoIndexManager = class {
       this.tracker.updateIndexStatus(attributeName, true);
       this.config.onIndexCreated(attributeName, indexType);
     } catch (error) {
-      console.error(`AutoIndexManager: Failed to create ${indexType} index on '${attributeName}':`, error);
+      logger.error({ err: error, attributeName, indexType, context: "index_creation" }, `AutoIndexManager: Failed to create ${indexType} index on '${attributeName}'`);
     }
   }
 };
@@ -9023,7 +9394,7 @@ var IndexedLWWMap = class extends LWWMap {
    * Execute a query using indexes.
    * Returns lazy ResultSet of matching keys.
    *
-   * Also tracks query patterns for adaptive indexing (Phase 8.02).
+   * Also tracks query patterns for adaptive indexing.
    *
    * @param query - Query to execute
    * @returns ResultSet of matching keys
@@ -9087,6 +9458,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": {
@@ -9392,7 +9781,7 @@ var IndexedLWWMap = class extends LWWMap {
   explainQuery(query) {
     return this.queryOptimizer.optimize(query);
   }
-  // ==================== Adaptive Indexing (Phase 8.02) ====================
+  // ==================== Adaptive Indexing ====================
   /**
    * Register an attribute for auto-indexing.
    * Required before auto-index can create indexes on this attribute.
@@ -9474,7 +9863,7 @@ var IndexedLWWMap = class extends LWWMap {
   isAutoIndexingEnabled() {
     return this.autoIndexManager !== null;
   }
-  // ==================== Lazy Indexing (Phase 9.01) ====================
+  // ==================== Lazy Indexing ====================
   /**
    * Check if lazy index building is enabled.
    */
@@ -10679,7 +11068,7 @@ var FullTextIndex = class {
 var IndexedORMap = class extends ORMap {
   constructor(hlc, options = {}) {
     super(hlc);
-    // Full-Text Search (Phase 11)
+    // Full-Text Search
     this.fullTextIndex = null;
     this.options = options;
     this.indexRegistry = new IndexRegistry();
@@ -10761,7 +11150,7 @@ var IndexedORMap = class extends ORMap {
     this.indexRegistry.addIndex(index);
     this.buildIndexFromExisting(index);
   }
-  // ==================== Full-Text Search (Phase 11) ====================
+  // ==================== Full-Text Search ====================
   /**
    * Enable BM25-based full-text search on specified fields.
    * This creates a FullTextIndex for relevance-ranked search.
@@ -10904,7 +11293,7 @@ var IndexedORMap = class extends ORMap {
    * Execute a query across all records.
    * Returns array of matching results with key, tag, and value.
    *
-   * Also tracks query patterns for adaptive indexing (Phase 8.02).
+   * Also tracks query patterns for adaptive indexing.
    *
    * @param query - Query to execute
    * @returns Array of query results
@@ -11270,7 +11659,7 @@ var IndexedORMap = class extends ORMap {
   explainQuery(query) {
     return this.queryOptimizer.optimize(query);
   }
-  // ==================== Adaptive Indexing (Phase 8.02) ====================
+  // ==================== Adaptive Indexing ====================
   /**
    * Register an attribute for auto-indexing.
    * Required before auto-index can create indexes on this attribute.
@@ -11603,13 +11992,1057 @@ var SearchCursor = class {
     };
   }
 };
+
+// src/debug/CRDTDebugger.ts
+var CRDTDebugger = class {
+  constructor(options = {}) {
+    this.snapshots = [];
+    this.conflicts = [];
+    this.idCounter = 0;
+    this.maxSnapshots = options.maxSnapshots || 1e4;
+    this.enabled = options.enabled ?? process.env.TOPGUN_DEBUG === "true";
+  }
+  // ============================================================================
+  // Recording Control
+  // ============================================================================
+  isEnabled() {
+    return this.enabled;
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  // ============================================================================
+  // Operation Recording
+  // ============================================================================
+  recordOperation(snapshot) {
+    if (!this.enabled) return;
+    this.snapshots.push({
+      ...snapshot,
+      id: `op-${++this.idCounter}`
+    });
+    if (this.snapshots.length > this.maxSnapshots) {
+      this.snapshots = this.snapshots.slice(-this.maxSnapshots);
+    }
+  }
+  recordSet(mapId, key, value, timestamp, nodeId, oldValue, merkleRoot) {
+    this.recordOperation({
+      timestamp,
+      operation: "set",
+      mapId,
+      key,
+      value,
+      oldValue,
+      nodeId,
+      merkleRoot
+    });
+  }
+  recordDelete(mapId, key, timestamp, nodeId, oldValue, merkleRoot) {
+    this.recordOperation({
+      timestamp,
+      operation: "delete",
+      mapId,
+      key,
+      oldValue,
+      nodeId,
+      merkleRoot
+    });
+  }
+  recordMerge(mapId, key, value, timestamp, nodeId, wasUpdated, oldValue, merkleRoot) {
+    this.recordOperation({
+      timestamp,
+      operation: "merge",
+      mapId,
+      key,
+      value,
+      oldValue,
+      nodeId,
+      merkleRoot,
+      metadata: { wasUpdated }
+    });
+  }
+  recordConflict(conflict) {
+    if (!this.enabled) return;
+    this.conflicts.push(conflict);
+  }
+  // ============================================================================
+  // Querying
+  // ============================================================================
+  getOperations(options = {}) {
+    let results = this.snapshots;
+    if (options.mapId) {
+      results = results.filter((s) => s.mapId === options.mapId);
+    }
+    if (options.nodeId) {
+      results = results.filter((s) => s.nodeId === options.nodeId);
+    }
+    if (options.operation) {
+      results = results.filter((s) => s.operation === options.operation);
+    }
+    if (options.since) {
+      results = results.filter(
+        (s) => this.compareTimestamp(s.timestamp, options.since) >= 0
+      );
+    }
+    if (options.until) {
+      results = results.filter(
+        (s) => this.compareTimestamp(s.timestamp, options.until) <= 0
+      );
+    }
+    if (options.limit) {
+      results = results.slice(-options.limit);
+    }
+    return results;
+  }
+  getConflicts(mapId) {
+    if (mapId) {
+      return this.conflicts.filter((c) => c.mapId === mapId);
+    }
+    return this.conflicts;
+  }
+  getLastOperation() {
+    return this.snapshots[this.snapshots.length - 1];
+  }
+  getOperationsForKey(mapId, key) {
+    return this.snapshots.filter((s) => s.mapId === mapId && s.key === key);
+  }
+  // ============================================================================
+  // Statistics
+  // ============================================================================
+  getStatistics(mapId) {
+    const ops = mapId ? this.snapshots.filter((s) => s.mapId === mapId) : this.snapshots;
+    const operationsByType = {};
+    const operationsByNode = {};
+    const uniqueKeys = /* @__PURE__ */ new Set();
+    for (const op of ops) {
+      operationsByType[op.operation] = (operationsByType[op.operation] || 0) + 1;
+      operationsByNode[op.nodeId] = (operationsByNode[op.nodeId] || 0) + 1;
+      if (op.key) uniqueKeys.add(op.key);
+    }
+    const timeRange = {
+      start: ops.length > 0 ? ops[0].timestamp : null,
+      end: ops.length > 0 ? ops[ops.length - 1].timestamp : null
+    };
+    let avgOpsPerSecond = 0;
+    if (timeRange.start && timeRange.end) {
+      const durationMs = timeRange.end.millis - timeRange.start.millis;
+      if (durationMs > 0) {
+        avgOpsPerSecond = ops.length / durationMs * 1e3;
+      }
+    }
+    return {
+      totalOperations: ops.length,
+      operationsByType,
+      operationsByNode,
+      conflictsResolved: this.conflicts.length,
+      timeRange,
+      uniqueKeys: uniqueKeys.size,
+      averageOpsPerSecond: avgOpsPerSecond
+    };
+  }
+  // ============================================================================
+  // Replay
+  // ============================================================================
+  /**
+   * Replays operations up to the target timestamp and returns the map state.
+   */
+  replayUntil(targetTimestamp, mapId, hlc) {
+    const map = new LWWMap(hlc || new HLC("replay-node"));
+    const ops = this.getOperations({ mapId, until: targetTimestamp });
+    for (const op of ops) {
+      if (op.operation === "set" && op.key !== void 0) {
+        const record = {
+          value: op.value,
+          timestamp: op.timestamp
+        };
+        map.merge(op.key, record);
+      } else if (op.operation === "delete" && op.key !== void 0) {
+        const record = {
+          value: null,
+          timestamp: op.timestamp
+        };
+        map.merge(op.key, record);
+      } else if (op.operation === "merge" && op.key !== void 0) {
+        const record = {
+          value: op.value,
+          timestamp: op.timestamp
+        };
+        map.merge(op.key, record);
+      }
+    }
+    return map;
+  }
+  /**
+   * Creates a timeline of operations grouped by time intervals.
+   */
+  getTimeline(intervalMs = 1e3, mapId) {
+    const ops = mapId ? this.snapshots.filter((s) => s.mapId === mapId) : this.snapshots;
+    if (ops.length === 0) return [];
+    const timeline = [];
+    let currentBucket = [];
+    let bucketStart = Math.floor(ops[0].timestamp.millis / intervalMs) * intervalMs;
+    for (const op of ops) {
+      const opBucket = Math.floor(op.timestamp.millis / intervalMs) * intervalMs;
+      if (opBucket !== bucketStart) {
+        if (currentBucket.length > 0) {
+          timeline.push({ timestamp: bucketStart, operations: currentBucket });
+        }
+        currentBucket = [];
+        bucketStart = opBucket;
+      }
+      currentBucket.push(op);
+    }
+    if (currentBucket.length > 0) {
+      timeline.push({ timestamp: bucketStart, operations: currentBucket });
+    }
+    return timeline;
+  }
+  // ============================================================================
+  // Export / Import
+  // ============================================================================
+  exportHistory(format = "json") {
+    switch (format) {
+      case "csv":
+        return this.toCSV();
+      case "ndjson":
+        return this.snapshots.map((s) => JSON.stringify(s)).join("\n");
+      default:
+        return JSON.stringify(
+          {
+            version: "1.0",
+            exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            statistics: this.getStatistics(),
+            operations: this.snapshots,
+            conflicts: this.conflicts
+          },
+          null,
+          2
+        );
+    }
+  }
+  toCSV() {
+    const header = "id,timestamp_millis,timestamp_counter,operation,map_id,key,node_id,merkle_root\n";
+    const rows = this.snapshots.map(
+      (s) => `${s.id},${s.timestamp.millis},${s.timestamp.counter},${s.operation},${s.mapId},${s.key || ""},${s.nodeId},${s.merkleRoot || ""}`
+    ).join("\n");
+    return header + rows;
+  }
+  importHistory(json) {
+    const data = JSON.parse(json);
+    if (data.version === "1.0") {
+      this.snapshots = data.operations || [];
+      this.conflicts = data.conflicts || [];
+      const maxId = this.snapshots.reduce((max, s) => {
+        const num = parseInt(s.id.replace("op-", ""), 10);
+        return isNaN(num) ? max : Math.max(max, num);
+      }, 0);
+      this.idCounter = maxId;
+    } else {
+      throw new Error(
+        'Unsupported history format. Expected v1.0 format with { version: "1.0", operations: [...], conflicts: [...] }. Legacy array format is no longer supported.'
+      );
+    }
+  }
+  // ============================================================================
+  // Diff
+  // ============================================================================
+  /**
+   * Compares two points in time and returns the differences.
+   */
+  diff(fromTimestamp, toTimestamp, mapId) {
+    const fromOps = this.getOperations({ mapId, until: fromTimestamp });
+    const toOps = this.getOperations({ mapId, until: toTimestamp });
+    const fromState = /* @__PURE__ */ new Map();
+    const toState = /* @__PURE__ */ new Map();
+    for (const op of fromOps) {
+      if (op.key) {
+        fromState.set(`${op.mapId}:${op.key}`, op);
+      }
+    }
+    for (const op of toOps) {
+      if (op.key) {
+        toState.set(`${op.mapId}:${op.key}`, op);
+      }
+    }
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    for (const [key, toOp] of toState) {
+      const fromOp = fromState.get(key);
+      if (!fromOp) {
+        if (toOp.operation !== "delete") {
+          added.push(toOp);
+        }
+      } else if (toOp.operation === "delete" && fromOp.operation !== "delete") {
+        deleted.push(toOp);
+      } else if (toOp.operation !== "delete" && JSON.stringify(toOp.value) !== JSON.stringify(fromOp.value)) {
+        modified.push(toOp);
+      }
+    }
+    return { added, modified, deleted };
+  }
+  // ============================================================================
+  // Utilities
+  // ============================================================================
+  clear() {
+    this.snapshots = [];
+    this.conflicts = [];
+    this.idCounter = 0;
+  }
+  compareTimestamp(a, b) {
+    if (a.millis !== b.millis) return a.millis - b.millis;
+    if (a.counter !== b.counter) return a.counter - b.counter;
+    return a.nodeId.localeCompare(b.nodeId);
+  }
+};
+var globalDebugger = null;
+function getCRDTDebugger() {
+  if (!globalDebugger) {
+    globalDebugger = new CRDTDebugger();
+  }
+  return globalDebugger;
+}
+function resetCRDTDebugger() {
+  globalDebugger = null;
+}
+
+// src/debug/SearchDebugger.ts
+var SearchDebugger = class {
+  constructor(options = {}) {
+    this.lastQuery = null;
+    this.history = [];
+    this.enabled = options.enabled ?? process.env.TOPGUN_DEBUG === "true";
+    this.maxHistory = options.maxHistory || 100;
+  }
+  // ============================================================================
+  // Control
+  // ============================================================================
+  isEnabled() {
+    return this.enabled;
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  // ============================================================================
+  // Recording
+  // ============================================================================
+  recordSearch(debugInfo) {
+    if (!this.enabled) return;
+    this.lastQuery = debugInfo;
+    this.history.push(debugInfo);
+    if (this.history.length > this.maxHistory) {
+      this.history = this.history.slice(-this.maxHistory);
+    }
+  }
+  // ============================================================================
+  // Querying
+  // ============================================================================
+  getLastQuery() {
+    return this.lastQuery;
+  }
+  getHistory() {
+    return this.history;
+  }
+  getHistoryByMap(mapId) {
+    return this.history.filter((q) => q.mapId === mapId);
+  }
+  explainResult(docId) {
+    return this.lastQuery?.results.find((r) => r.docId === docId);
+  }
+  // ============================================================================
+  // Formatting
+  // ============================================================================
+  formatExplanation(docId) {
+    const result = this.explainResult(docId);
+    if (!result) return "No debug info available for this document.";
+    const lines = [];
+    lines.push(`Score Breakdown for ${docId}`);
+    lines.push(`Final Score: ${result.finalScore.toFixed(4)}`);
+    lines.push("");
+    if (result.scoreBreakdown.bm25) {
+      const bm25 = result.scoreBreakdown.bm25;
+      lines.push("BM25 Full-Text Search:");
+      lines.push(`  Score: ${bm25.score.toFixed(4)}`);
+      lines.push(
+        `  Document length: ${bm25.docLength} (avg: ${bm25.avgDocLength.toFixed(1)})`
+      );
+      lines.push(`  Parameters: k1=${bm25.k1}, b=${bm25.b}`);
+      lines.push("  Term contributions:");
+      for (const term of bm25.matchedTerms) {
+        const tf = bm25.tf[term] || 0;
+        const idf = bm25.idf[term] || 0;
+        const contribution = tf * idf;
+        lines.push(
+          `    "${term}": TF=${tf.toFixed(3)}, IDF=${idf.toFixed(3)}, contribution=${contribution.toFixed(4)}`
+        );
+      }
+      lines.push("");
+    }
+    if (result.scoreBreakdown.exact) {
+      const exact = result.scoreBreakdown.exact;
+      lines.push("Exact Match:");
+      lines.push(`  Score: ${exact.score.toFixed(4)}`);
+      lines.push(`  Matched fields: ${exact.matchedFields.join(", ")}`);
+      lines.push(`  Boost applied: ${exact.boostApplied}x`);
+      lines.push("");
+    }
+    if (result.scoreBreakdown.rrf) {
+      const rrf = result.scoreBreakdown.rrf;
+      lines.push("Reciprocal Rank Fusion (RRF):");
+      lines.push(`  Final rank: ${rrf.rank}`);
+      lines.push(`  RRF score: ${rrf.score.toFixed(4)}`);
+      lines.push(`  k parameter: ${rrf.k}`);
+      lines.push("  Contributing ranks:");
+      for (const contrib of rrf.contributingRanks) {
+        lines.push(`    ${contrib.source}: rank ${contrib.rank}`);
+      }
+      lines.push("");
+    }
+    if (result.scoreBreakdown.vector) {
+      const vector = result.scoreBreakdown.vector;
+      lines.push("Vector Similarity:");
+      lines.push(`  Score: ${vector.score.toFixed(4)}`);
+      lines.push(`  Distance: ${vector.distance.toFixed(4)}`);
+      lines.push(`  Metric: ${vector.similarity}`);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  formatQuerySummary() {
+    if (!this.lastQuery) return "No query recorded.";
+    const q = this.lastQuery;
+    const lines = [];
+    lines.push(`Query: "${q.query}"`);
+    lines.push(`Tokens: ${q.queryTokens.join(", ")}`);
+    lines.push(`Type: ${q.searchType}`);
+    lines.push(`Results: ${q.matchingDocuments} of ${q.totalDocuments} documents`);
+    lines.push("");
+    lines.push("Timing:");
+    lines.push(`  Tokenization: ${q.timing.tokenization.toFixed(2)}ms`);
+    lines.push(`  Index lookup: ${q.timing.indexLookup.toFixed(2)}ms`);
+    lines.push(`  Scoring: ${q.timing.scoring.toFixed(2)}ms`);
+    lines.push(`  Ranking: ${q.timing.ranking.toFixed(2)}ms`);
+    if (q.timing.fusion !== void 0) {
+      lines.push(`  Fusion: ${q.timing.fusion.toFixed(2)}ms`);
+    }
+    lines.push(`  Total: ${q.timing.total.toFixed(2)}ms`);
+    lines.push("");
+    lines.push("Index stats:");
+    lines.push(`  Type: ${q.indexStats.indexType}`);
+    lines.push(`  Size: ${q.indexStats.indexSize} entries`);
+    lines.push(`  Terms searched: ${q.indexStats.termsSearched}`);
+    return lines.join("\n");
+  }
+  formatAllResults() {
+    if (!this.lastQuery) return "No query recorded.";
+    const lines = [];
+    lines.push(this.formatQuerySummary());
+    lines.push("");
+    lines.push("Results:");
+    lines.push("");
+    for (let i = 0; i < this.lastQuery.results.length; i++) {
+      const result = this.lastQuery.results[i];
+      lines.push(`${i + 1}. ${result.docId}`);
+      lines.push(`   Final score: ${result.finalScore.toFixed(4)}`);
+      if (result.scoreBreakdown.bm25) {
+        const bm25 = result.scoreBreakdown.bm25;
+        lines.push(`   BM25: ${bm25.score.toFixed(4)}`);
+        const topTerms = bm25.matchedTerms.slice(0, 3);
+        for (const term of topTerms) {
+          lines.push(
+            `     - "${term}": TF=${bm25.tf[term]?.toFixed(3)}, IDF=${bm25.idf[term]?.toFixed(3)}`
+          );
+        }
+      }
+      if (result.scoreBreakdown.exact) {
+        lines.push(
+          `   Exact: ${result.scoreBreakdown.exact.score.toFixed(4)} (${result.scoreBreakdown.exact.matchedFields.join(", ")})`
+        );
+      }
+      if (result.scoreBreakdown.rrf) {
+        lines.push(`   RRF rank: ${result.scoreBreakdown.rrf.rank}`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  // ============================================================================
+  // Export
+  // ============================================================================
+  exportDebugInfo() {
+    return JSON.stringify(this.lastQuery, null, 2);
+  }
+  exportHistory() {
+    return JSON.stringify(
+      {
+        version: "1.0",
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        queryCount: this.history.length,
+        queries: this.history
+      },
+      null,
+      2
+    );
+  }
+  // ============================================================================
+  // Analysis
+  // ============================================================================
+  getSearchStats() {
+    if (this.history.length === 0) {
+      return {
+        totalQueries: 0,
+        averageResultCount: 0,
+        averageLatencyMs: 0,
+        queryTypeBreakdown: {}
+      };
+    }
+    const queryTypeBreakdown = {};
+    let totalResults = 0;
+    let totalLatency = 0;
+    for (const q of this.history) {
+      queryTypeBreakdown[q.searchType] = (queryTypeBreakdown[q.searchType] || 0) + 1;
+      totalResults += q.matchingDocuments;
+      totalLatency += q.timing.total;
+    }
+    return {
+      totalQueries: this.history.length,
+      averageResultCount: totalResults / this.history.length,
+      averageLatencyMs: totalLatency / this.history.length,
+      queryTypeBreakdown
+    };
+  }
+  // ============================================================================
+  // Utilities
+  // ============================================================================
+  clear() {
+    this.lastQuery = null;
+    this.history = [];
+  }
+};
+var globalSearchDebugger = null;
+function getSearchDebugger() {
+  if (!globalSearchDebugger) {
+    globalSearchDebugger = new SearchDebugger();
+  }
+  return globalSearchDebugger;
+}
+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 = {
+  AuthFailMessageSchema,
   AuthMessageSchema,
   BM25Scorer,
   BatchMessageSchema,
   BuiltInProcessors,
   BuiltInResolvers,
+  COST_WEIGHTS,
+  CRDTDebugger,
+  CRDTInvariants,
   ClientOpMessageSchema,
   ClientOpSchema,
   ClusterSearchReqMessageSchema,
@@ -11651,6 +13084,7 @@ var SearchCursor = class {
   DEFAULT_RESOLVER_RATE_LIMITS,
   DEFAULT_STOP_WORDS,
   DEFAULT_WRITE_CONCERN_TIMEOUT,
+  DeltaRecordSchema,
   ENGLISH_STOPWORDS,
   EntryProcessBatchRequestSchema,
   EntryProcessBatchResponseSchema,
@@ -11666,12 +13100,24 @@ var SearchCursor = class {
   FallbackIndex,
   FilteringResultSet,
   FullTextIndex,
+  GcPruneMessageSchema,
+  GcPrunePayloadSchema,
   HLC,
   HashIndex,
+  HttpQueryRequestSchema,
+  HttpQueryResultSchema,
+  HttpSearchRequestSchema,
+  HttpSearchResultSchema,
+  HttpSyncErrorSchema,
+  HttpSyncRequestSchema,
+  HttpSyncResponseSchema,
+  HybridQueryDeltaPayloadSchema,
+  HybridQueryRespPayloadSchema,
   IndexRegistry,
   IndexedLWWMap,
   IndexedORMap,
   IntersectionResultSet,
+  InvariantChecker,
   InvertedIndex,
   JournalEventDataSchema,
   JournalEventMessageSchema,
@@ -11687,9 +13133,12 @@ var SearchCursor = class {
   ListResolversRequestSchema,
   ListResolversResponseSchema,
   LiveQueryManager,
+  LockGrantedPayloadSchema,
   LockReleaseSchema,
+  LockReleasedPayloadSchema,
   LockRequestSchema,
   LowercaseFilter,
+  MapDeltaSchema,
   MaxLengthFilter,
   MergeRejectedMessageSchema,
   MerkleReqBucketMessageSchema,
@@ -11731,12 +13180,17 @@ var SearchCursor = class {
   QuerySchema,
   QuerySubMessageSchema,
   QueryUnsubMessageSchema,
+  QueryUpdateMessageSchema,
+  QueryUpdatePayloadSchema,
   RESOLVER_FORBIDDEN_PATTERNS,
+  RealClock,
   ReciprocalRankFusion,
   RegisterResolverRequestSchema,
   RegisterResolverResponseSchema,
   Ringbuffer,
+  ScenarioRunner,
   SearchCursor,
+  SearchDebugger,
   SearchMessageSchema,
   SearchOptionsSchema,
   SearchPayloadSchema,
@@ -11749,6 +13203,10 @@ var SearchCursor = class {
   SearchUpdateMessageSchema,
   SearchUpdatePayloadSchema,
   SearchUpdateTypeSchema,
+  SeededRNG,
+  ServerBatchEventMessageSchema,
+  ServerEventMessageSchema,
+  ServerEventPayloadSchema,
   SetResultSet,
   SimpleAttribute,
   SortedMap,
@@ -11757,6 +13215,8 @@ var SearchCursor = class {
   StandingQueryRegistry,
   StopWordFilter,
   SyncInitMessageSchema,
+  SyncMapEntrySchema,
+  SyncResetRequiredPayloadSchema,
   SyncRespBucketsMessageSchema,
   SyncRespLeafMessageSchema,
   SyncRespRootMessageSchema,
@@ -11771,11 +13231,14 @@ var SearchCursor = class {
   UniqueFilter,
   UnregisterResolverRequestSchema,
   UnregisterResolverResponseSchema,
+  VirtualClock,
+  VirtualNetwork,
   WRITE_CONCERN_ORDER,
   WhitespaceTokenizer,
   WordBoundaryTokenizer,
   WriteConcern,
   WriteConcernSchema,
+  calculateTotalCost,
   combineHashes,
   compareHLCTimestamps,
   compareTimestamps,
@@ -11788,7 +13251,9 @@ var SearchCursor = class {
   disableNativeHash,
   encodeBase64Url,
   evaluatePredicate,
+  getCRDTDebugger,
   getHighestWriteConcernLevel,
+  getSearchDebugger,
   hashORMapEntry,
   hashORMapRecord,
   hashObject,
@@ -11797,9 +13262,12 @@ var SearchCursor = class {
   isSimpleQuery,
   isUsingNativeHash,
   isWriteConcernAchieved,
+  logger,
   multiAttribute,
   porterStem,
+  resetCRDTDebugger,
   resetNativeHash,
+  resetSearchDebugger,
   serialize,
   simpleAttribute,
   timestampToString,