@topgunbuild/core 0.10.0 → 0.10.1

package/dist/index.js

@@ -30,11 +30,13 @@ 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,
+  CRDTDebugger: () => CRDTDebugger,
   ClientOpMessageSchema: () => ClientOpMessageSchema,
   ClientOpSchema: () => ClientOpSchema,
   ClusterSearchReqMessageSchema: () => ClusterSearchReqMessageSchema,
@@ -91,8 +93,12 @@ __export(index_exports, {
   FallbackIndex: () => FallbackIndex,
   FilteringResultSet: () => FilteringResultSet,
   FullTextIndex: () => FullTextIndex,
+  GcPruneMessageSchema: () => GcPruneMessageSchema,
+  GcPrunePayloadSchema: () => GcPrunePayloadSchema,
   HLC: () => HLC,
   HashIndex: () => HashIndex,
+  HybridQueryDeltaPayloadSchema: () => HybridQueryDeltaPayloadSchema,
+  HybridQueryRespPayloadSchema: () => HybridQueryRespPayloadSchema,
   IndexRegistry: () => IndexRegistry,
   IndexedLWWMap: () => IndexedLWWMap,
   IndexedORMap: () => IndexedORMap,
@@ -112,7 +118,9 @@ __export(index_exports, {
   ListResolversRequestSchema: () => ListResolversRequestSchema,
   ListResolversResponseSchema: () => ListResolversResponseSchema,
   LiveQueryManager: () => LiveQueryManager,
+  LockGrantedPayloadSchema: () => LockGrantedPayloadSchema,
   LockReleaseSchema: () => LockReleaseSchema,
+  LockReleasedPayloadSchema: () => LockReleasedPayloadSchema,
   LockRequestSchema: () => LockRequestSchema,
   LowercaseFilter: () => LowercaseFilter,
   MaxLengthFilter: () => MaxLengthFilter,
@@ -156,12 +164,15 @@ __export(index_exports, {
   QuerySchema: () => QuerySchema,
   QuerySubMessageSchema: () => QuerySubMessageSchema,
   QueryUnsubMessageSchema: () => QueryUnsubMessageSchema,
+  QueryUpdateMessageSchema: () => QueryUpdateMessageSchema,
+  QueryUpdatePayloadSchema: () => QueryUpdatePayloadSchema,
   RESOLVER_FORBIDDEN_PATTERNS: () => RESOLVER_FORBIDDEN_PATTERNS,
   ReciprocalRankFusion: () => ReciprocalRankFusion,
   RegisterResolverRequestSchema: () => RegisterResolverRequestSchema,
   RegisterResolverResponseSchema: () => RegisterResolverResponseSchema,
   Ringbuffer: () => Ringbuffer,
   SearchCursor: () => SearchCursor,
+  SearchDebugger: () => SearchDebugger,
   SearchMessageSchema: () => SearchMessageSchema,
   SearchOptionsSchema: () => SearchOptionsSchema,
   SearchPayloadSchema: () => SearchPayloadSchema,
@@ -174,6 +185,9 @@ __export(index_exports, {
   SearchUpdateMessageSchema: () => SearchUpdateMessageSchema,
   SearchUpdatePayloadSchema: () => SearchUpdatePayloadSchema,
   SearchUpdateTypeSchema: () => SearchUpdateTypeSchema,
+  ServerBatchEventMessageSchema: () => ServerBatchEventMessageSchema,
+  ServerEventMessageSchema: () => ServerEventMessageSchema,
+  ServerEventPayloadSchema: () => ServerEventPayloadSchema,
   SetResultSet: () => SetResultSet,
   SimpleAttribute: () => SimpleAttribute,
   SortedMap: () => SortedMap,
@@ -182,6 +196,7 @@ __export(index_exports, {
   StandingQueryRegistry: () => StandingQueryRegistry,
   StopWordFilter: () => StopWordFilter,
   SyncInitMessageSchema: () => SyncInitMessageSchema,
+  SyncResetRequiredPayloadSchema: () => SyncResetRequiredPayloadSchema,
   SyncRespBucketsMessageSchema: () => SyncRespBucketsMessageSchema,
   SyncRespLeafMessageSchema: () => SyncRespLeafMessageSchema,
   SyncRespRootMessageSchema: () => SyncRespRootMessageSchema,
@@ -213,7 +228,9 @@ __export(index_exports, {
   disableNativeHash: () => disableNativeHash,
   encodeBase64Url: () => encodeBase64Url,
   evaluatePredicate: () => evaluatePredicate,
+  getCRDTDebugger: () => getCRDTDebugger,
   getHighestWriteConcernLevel: () => getHighestWriteConcernLevel,
+  getSearchDebugger: () => getSearchDebugger,
   hashORMapEntry: () => hashORMapEntry,
   hashORMapRecord: () => hashORMapRecord,
   hashObject: () => hashObject,
@@ -222,9 +239,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,16 +253,34 @@ __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.lastMillis = 0;
     this.lastCounter = 0;
   }
   get getNodeId() {
     return this.nodeId;
   }
+  get getStrictMode() {
+    return this.strictMode;
+  }
+  get getMaxDriftMs() {
+    return this.maxDriftMs;
+  }
   /**
    * Generates a new unique timestamp for a local event.
    * Ensures monotonicity: always greater than any previously generated or received timestamp.
@@ -267,8 +305,18 @@ var _HLC = class _HLC {
    */
   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 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 +365,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;
@@ -1508,7 +1553,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 +1599,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 +2258,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 +2402,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 +2452,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 +2469,674 @@ 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 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 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 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 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 TopicSubSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("TOPIC_SUB"),
-  payload: import_zod3.z.object({
-    topic: import_zod3.z.string()
+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 TopicUnsubSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("TOPIC_UNSUB"),
-  payload: import_zod3.z.object({
-    topic: import_zod3.z.string()
+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 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 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 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 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 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 CounterRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("COUNTER_REQUEST"),
-  payload: import_zod3.z.object({
-    name: import_zod3.z.string()
+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 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 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 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 OpResultSchema = import_zod4.z.object({
+  opId: import_zod4.z.string(),
+  success: import_zod4.z.boolean(),
+  achievedLevel: WriteConcernSchema,
+  error: import_zod4.z.string().optional()
+});
+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 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 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 PingMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("PING"),
-  timestamp: import_zod3.z.number()
-  // Client's Date.now()
+var BatchMessageSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("BATCH"),
+  count: import_zod4.z.number(),
+  data: import_zod4.z.instanceof(Uint8Array)
 });
-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)
+
+// 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 BatchMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("BATCH"),
-  count: import_zod3.z.number(),
-  data: import_zod3.z.instanceof(Uint8Array)
+var QueryUnsubMessageSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("QUERY_UNSUB"),
+  payload: import_zod5.z.object({
+    queryId: import_zod5.z.string()
+  })
 });
-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 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 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 QueryRespMessageSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("QUERY_RESP"),
+  payload: QueryRespPayloadSchema
 });
-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())
-  })
+
+// 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 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 SearchPayloadSchema = import_zod6.z.object({
+  requestId: import_zod6.z.string(),
+  mapName: import_zod6.z.string(),
+  query: import_zod6.z.string(),
+  options: SearchOptionsSchema.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 SearchMessageSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SEARCH"),
+  payload: SearchPayloadSchema
 });
-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 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 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 SearchRespMessageSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SEARCH_RESP"),
+  payload: SearchRespPayloadSchema
 });
-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 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 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 SearchSubMessageSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SEARCH_SUB"),
+  payload: SearchSubPayloadSchema
 });
-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 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 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(),
-  processor: EntryProcessorSchema
+var SearchUpdateMessageSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SEARCH_UPDATE"),
+  payload: SearchUpdatePayloadSchema
 });
-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()),
-  processor: EntryProcessorSchema
+var SearchUnsubPayloadSchema = import_zod6.z.object({
+  subscriptionId: import_zod6.z.string()
 });
-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 SearchUnsubMessageSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SEARCH_UNSUB"),
+  payload: SearchUnsubPayloadSchema
 });
-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()
+
+// 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 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 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 JournalEventTypeSchema = import_zod3.z.enum(["PUT", "UPDATE", "DELETE"]);
-var JournalEventDataSchema = import_zod3.z.object({
-  sequence: import_zod3.z.string(),
-  // bigint as 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(),
-  timestamp: TimestampSchema,
-  nodeId: import_zod3.z.string(),
-  metadata: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+var ClusterSubRegisterMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SUB_REGISTER"),
+  payload: ClusterSubRegisterPayloadSchema
 });
-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 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 JournalUnsubscribeRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("JOURNAL_UNSUBSCRIBE"),
-  subscriptionId: import_zod3.z.string()
+var ClusterSubAckMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SUB_ACK"),
+  payload: ClusterSubAckPayloadSchema
 });
-var JournalEventMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("JOURNAL_EVENT"),
-  event: JournalEventDataSchema
+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 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 ClusterSubUpdateMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SUB_UPDATE"),
+  payload: ClusterSubUpdatePayloadSchema
 });
-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 ClusterSubUnregisterPayloadSchema = import_zod7.z.object({
+  subscriptionId: import_zod7.z.string()
 });
-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 ClusterSubUnregisterMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SUB_UNREGISTER"),
+  payload: ClusterSubUnregisterPayloadSchema
 });
-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 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 SearchMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SEARCH"),
-  payload: SearchPayloadSchema
+var ClusterSearchReqMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SEARCH_REQ"),
+  payload: ClusterSearchReqPayloadSchema
 });
-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())
+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()
   })),
-  totalCount: import_zod3.z.number(),
-  error: import_zod3.z.string().optional()
+  totalHits: import_zod7.z.number().int().nonnegative(),
+  executionTimeMs: import_zod7.z.number().nonnegative(),
+  error: import_zod7.z.string().optional()
 });
-var SearchRespMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SEARCH_RESP"),
-  payload: SearchRespPayloadSchema
+var ClusterSearchRespMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SEARCH_RESP"),
+  payload: ClusterSearchRespPayloadSchema
 });
-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(),
+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 SearchSubMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SEARCH_SUB"),
-  payload: SearchSubPayloadSchema
+var ClusterSearchSubscribeMessageSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("CLUSTER_SEARCH_SUBSCRIBE"),
+  payload: ClusterSearchSubscribePayloadSchema
 });
-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()),
+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 SearchUpdateMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SEARCH_UPDATE"),
-  payload: SearchUpdatePayloadSchema
+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 SearchUnsubPayloadSchema = import_zod3.z.object({
-  subscriptionId: import_zod3.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 SearchUnsubMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("SEARCH_UNSUB"),
-  payload: SearchUnsubPayloadSchema
+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 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 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 RegisterResolverRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("REGISTER_RESOLVER"),
-  requestId: import_zod3.z.string(),
-  mapName: 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 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 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 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 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 PingMessageSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("PING"),
+  timestamp: import_zod8.z.number()
+});
+var PongMessageSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("PONG"),
+  timestamp: import_zod8.z.number(),
+  serverTime: import_zod8.z.number()
+});
+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_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_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_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_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_zod8.z.enum(["PUT", "UPDATE", "DELETE"]);
+var JournalEventDataSchema = import_zod8.z.object({
+  sequence: import_zod8.z.string(),
+  type: JournalEventTypeSchema,
+  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_zod8.z.string(),
+  metadata: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).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_zod8.z.object({
+  type: import_zod8.z.literal("JOURNAL_UNSUBSCRIBE"),
+  subscriptionId: import_zod8.z.string()
+});
+var JournalEventMessageSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("JOURNAL_EVENT"),
+  event: JournalEventDataSchema
+});
+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_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 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 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 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 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 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 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 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 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 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(),
+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 ListResolversRequestSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("LIST_RESOLVERS"),
-  requestId: import_zod3.z.string(),
-  mapName: import_zod3.z.string().optional()
+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 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 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 OpResultSchema = import_zod3.z.object({
-  opId: import_zod3.z.string(),
-  success: import_zod3.z.boolean(),
-  achievedLevel: WriteConcernSchema,
-  error: import_zod3.z.string().optional()
+
+// 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 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 ServerEventMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("SERVER_EVENT"),
+  payload: ServerEventPayloadSchema
 });
-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()
+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 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 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 ClusterSubRegisterMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SUB_REGISTER"),
-  payload: ClusterSubRegisterPayloadSchema
+var QueryUpdateMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("QUERY_UPDATE"),
+  payload: QueryUpdatePayloadSchema
 });
-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 GcPrunePayloadSchema = import_zod9.z.object({
+  olderThan: TimestampSchema
 });
-var ClusterSubAckMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SUB_ACK"),
-  payload: ClusterSubAckPayloadSchema
+var GcPruneMessageSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("GC_PRUNE"),
+  payload: GcPrunePayloadSchema
 });
-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 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 ClusterSubUpdateMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SUB_UPDATE"),
-  payload: ClusterSubUpdatePayloadSchema
+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 ClusterSubUnregisterPayloadSchema = import_zod3.z.object({
-  /** Subscription ID to remove */
-  subscriptionId: import_zod3.z.string()
+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 ClusterSubUnregisterMessageSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("CLUSTER_SUB_UNREGISTER"),
-  payload: ClusterSubUnregisterPayloadSchema
+var LockGrantedPayloadSchema = import_zod9.z.object({
+  requestId: import_zod9.z.string(),
+  fencingToken: import_zod9.z.number()
+});
+var LockReleasedPayloadSchema = import_zod9.z.object({
+  requestId: import_zod9.z.string(),
+  success: import_zod9.z.boolean()
+});
+var SyncResetRequiredPayloadSchema = import_zod9.z.object({
+  mapName: import_zod9.z.string(),
+  reason: import_zod9.z.string()
 });
-var MessageSchema = import_zod3.z.discriminatedUnion("type", [
+
+// src/schemas/index.ts
+var import_zod10 = require("zod");
+var MessageSchema = import_zod10.z.discriminatedUnion("type", [
   AuthMessageSchema,
   QuerySubMessageSchema,
   QueryUnsubMessageSchema,
@@ -3002,7 +3154,6 @@ var MessageSchema = import_zod3.z.discriminatedUnion("type", [
   TopicPubSchema,
   PingMessageSchema,
   PongMessageSchema,
-  // ORMap Sync Messages
   ORMapSyncInitSchema,
   ORMapSyncRespRootSchema,
   ORMapSyncRespBucketsSchema,
@@ -3011,23 +3162,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 +3181,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) => {
@@ -6054,7 +6115,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 +6142,7 @@ var IndexRegistry = class {
     }
   }
   /**
-   * Register a compound index (Phase 9.03).
+   * Register a compound index.
    *
    * @param index - Compound index to register
    */
@@ -6115,7 +6176,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 +6256,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 +6277,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 +6286,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 +6424,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 +6441,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 +6449,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 +6458,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
@@ -6477,7 +6531,7 @@ var QueryOptimizer = class {
       sort: sortField && sortDirection ? { field: sortField, direction: sortDirection } : void 0,
       limit: options.limit,
       cursor: options.cursor
-      // Phase 14.1: replaces offset
+      // replaces offset
     };
   }
   /**
@@ -6495,7 +6549,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 +6559,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 +6599,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 +6610,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 +6651,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 +6673,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 +6717,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 +6758,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
@@ -6886,7 +6940,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":
@@ -6918,7 +6972,7 @@ var QueryOptimizer = class {
         return this.usesIndexes(step.source);
       case "not":
         return this.usesIndexes(step.source);
-      // Phase 12: FTS step types
+      // FTS step types
       case "fts-scan":
         return true;
       // FTS uses FullTextIndex
@@ -7175,7 +7229,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 +7328,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 +7463,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 +7503,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 +7693,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 +7709,7 @@ var QueryPatternTracker = class {
     }
   }
   /**
-   * Prune stale compound statistics (Phase 9.03).
+   * Prune stale compound statistics.
    */
   pruneStaleCompound() {
     const cutoff = Date.now() - this.statsTtl;
@@ -7904,7 +7958,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 +8279,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 +9077,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
@@ -9392,7 +9446,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 +9528,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 +10733,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 +10815,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 +10958,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 +11324,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 +11657,557 @@ 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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AuthFailMessageSchema,
   AuthMessageSchema,
   BM25Scorer,
   BatchMessageSchema,
   BuiltInProcessors,
   BuiltInResolvers,
+  CRDTDebugger,
   ClientOpMessageSchema,
   ClientOpSchema,
   ClusterSearchReqMessageSchema,
@@ -11666,8 +12264,12 @@ var SearchCursor = class {
   FallbackIndex,
   FilteringResultSet,
   FullTextIndex,
+  GcPruneMessageSchema,
+  GcPrunePayloadSchema,
   HLC,
   HashIndex,
+  HybridQueryDeltaPayloadSchema,
+  HybridQueryRespPayloadSchema,
   IndexRegistry,
   IndexedLWWMap,
   IndexedORMap,
@@ -11687,7 +12289,9 @@ var SearchCursor = class {
   ListResolversRequestSchema,
   ListResolversResponseSchema,
   LiveQueryManager,
+  LockGrantedPayloadSchema,
   LockReleaseSchema,
+  LockReleasedPayloadSchema,
   LockRequestSchema,
   LowercaseFilter,
   MaxLengthFilter,
@@ -11731,12 +12335,15 @@ var SearchCursor = class {
   QuerySchema,
   QuerySubMessageSchema,
   QueryUnsubMessageSchema,
+  QueryUpdateMessageSchema,
+  QueryUpdatePayloadSchema,
   RESOLVER_FORBIDDEN_PATTERNS,
   ReciprocalRankFusion,
   RegisterResolverRequestSchema,
   RegisterResolverResponseSchema,
   Ringbuffer,
   SearchCursor,
+  SearchDebugger,
   SearchMessageSchema,
   SearchOptionsSchema,
   SearchPayloadSchema,
@@ -11749,6 +12356,9 @@ var SearchCursor = class {
   SearchUpdateMessageSchema,
   SearchUpdatePayloadSchema,
   SearchUpdateTypeSchema,
+  ServerBatchEventMessageSchema,
+  ServerEventMessageSchema,
+  ServerEventPayloadSchema,
   SetResultSet,
   SimpleAttribute,
   SortedMap,
@@ -11757,6 +12367,7 @@ var SearchCursor = class {
   StandingQueryRegistry,
   StopWordFilter,
   SyncInitMessageSchema,
+  SyncResetRequiredPayloadSchema,
   SyncRespBucketsMessageSchema,
   SyncRespLeafMessageSchema,
   SyncRespRootMessageSchema,
@@ -11788,7 +12399,9 @@ var SearchCursor = class {
   disableNativeHash,
   encodeBase64Url,
   evaluatePredicate,
+  getCRDTDebugger,
   getHighestWriteConcernLevel,
+  getSearchDebugger,
   hashORMapEntry,
   hashORMapRecord,
   hashObject,
@@ -11797,9 +12410,12 @@ var SearchCursor = class {
   isSimpleQuery,
   isUsingNativeHash,
   isWriteConcernAchieved,
+  logger,
   multiAttribute,
   porterStem,
+  resetCRDTDebugger,
   resetNativeHash,
+  resetSearchDebugger,
   serialize,
   simpleAttribute,
   timestampToString,