@topgunbuild/core 0.9.0 → 0.10.0

package/dist/index.mjs

@@ -138,6 +138,18 @@ function resetNativeHash() {
   nativeHash = null;
   nativeLoadAttempted = false;
 }
+function hashObject(obj) {
+  const json = JSON.stringify(obj, (_, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return Object.keys(value).sort().reduce((sorted, key) => {
+        sorted[key] = value[key];
+        return sorted;
+      }, {});
+    }
+    return value;
+  });
+  return hashString(json);
+}
 
 // src/MerkleTree.ts
 var MerkleTree = class {
@@ -2166,7 +2178,24 @@ var QuerySchema = z3.object({
   predicate: PredicateNodeSchema.optional(),
   sort: z3.record(z3.string(), z3.enum(["asc", "desc"])).optional(),
   limit: z3.number().optional(),
-  offset: z3.number().optional()
+  cursor: z3.string().optional()
+  // Phase 14.1: replaces offset
+});
+var CursorStatusSchema = z3.enum(["valid", "expired", "invalid", "none"]);
+var QueryRespPayloadSchema = z3.object({
+  queryId: z3.string(),
+  results: z3.array(z3.object({
+    key: z3.string(),
+    value: z3.unknown()
+  })),
+  nextCursor: z3.string().optional(),
+  hasMore: z3.boolean().optional(),
+  /** Debug info: status of input cursor processing */
+  cursorStatus: CursorStatusSchema.optional()
+});
+var QueryRespMessageSchema = z3.object({
+  type: z3.literal("QUERY_RESP"),
+  payload: QueryRespPayloadSchema
 });
 var ClientOpSchema = z3.object({
   id: z3.string().optional(),
@@ -2646,6 +2675,87 @@ var OpRejectedMessageSchema = z3.object({
     code: z3.number().optional()
   })
 });
+var ClusterSubRegisterPayloadSchema = z3.object({
+  /** Unique subscription ID */
+  subscriptionId: z3.string(),
+  /** Node ID of the coordinator (receives updates) */
+  coordinatorNodeId: z3.string(),
+  /** Map name to subscribe to */
+  mapName: z3.string(),
+  /** Subscription type */
+  type: z3.enum(["SEARCH", "QUERY"]),
+  // For FTS subscriptions
+  /** Search query string (for SEARCH type) */
+  searchQuery: z3.string().optional(),
+  /** Search options (for SEARCH type) */
+  searchOptions: z3.object({
+    limit: z3.number().int().positive().optional(),
+    minScore: z3.number().optional(),
+    boost: z3.record(z3.string(), z3.number()).optional()
+  }).optional(),
+  // For Query subscriptions
+  /** Query predicate (for QUERY type) */
+  queryPredicate: z3.any().optional(),
+  /** Query sort order (for QUERY type) */
+  querySort: z3.record(z3.string(), z3.enum(["asc", "desc"])).optional()
+});
+var ClusterSubRegisterMessageSchema = z3.object({
+  type: z3.literal("CLUSTER_SUB_REGISTER"),
+  payload: ClusterSubRegisterPayloadSchema
+});
+var ClusterSubAckPayloadSchema = z3.object({
+  /** Correlates to subscriptionId */
+  subscriptionId: z3.string(),
+  /** Node that registered this subscription */
+  nodeId: z3.string(),
+  /** Registration success status */
+  success: z3.boolean(),
+  /** Error message if failed */
+  error: z3.string().optional(),
+  /** Initial results from this node */
+  initialResults: z3.array(z3.object({
+    key: z3.string(),
+    value: z3.unknown(),
+    score: z3.number().optional(),
+    matchedTerms: z3.array(z3.string()).optional()
+  })).optional(),
+  /** Total matching documents on this node */
+  totalHits: z3.number().int().nonnegative().optional()
+});
+var ClusterSubAckMessageSchema = z3.object({
+  type: z3.literal("CLUSTER_SUB_ACK"),
+  payload: ClusterSubAckPayloadSchema
+});
+var ClusterSubUpdatePayloadSchema = z3.object({
+  /** Subscription ID this update belongs to */
+  subscriptionId: z3.string(),
+  /** Node that produced this update */
+  sourceNodeId: z3.string(),
+  /** Document key */
+  key: z3.string(),
+  /** Document value (null for LEAVE) */
+  value: z3.unknown(),
+  /** Search score (for SEARCH type) */
+  score: z3.number().optional(),
+  /** Matched terms (for SEARCH type) */
+  matchedTerms: z3.array(z3.string()).optional(),
+  /** Change type: ENTER (new match), UPDATE (still matches), LEAVE (no longer matches) */
+  changeType: z3.enum(["ENTER", "UPDATE", "LEAVE"]),
+  /** Timestamp for ordering */
+  timestamp: z3.number()
+});
+var ClusterSubUpdateMessageSchema = z3.object({
+  type: z3.literal("CLUSTER_SUB_UPDATE"),
+  payload: ClusterSubUpdatePayloadSchema
+});
+var ClusterSubUnregisterPayloadSchema = z3.object({
+  /** Subscription ID to remove */
+  subscriptionId: z3.string()
+});
+var ClusterSubUnregisterMessageSchema = z3.object({
+  type: z3.literal("CLUSTER_SUB_UNREGISTER"),
+  payload: ClusterSubUnregisterPayloadSchema
+});
 var MessageSchema = z3.discriminatedUnion("type", [
   AuthMessageSchema,
   QuerySubMessageSchema,
@@ -2703,8 +2813,95 @@ var MessageSchema = z3.discriminatedUnion("type", [
   // Phase 11.1b: Live Search Subscriptions
   SearchSubMessageSchema,
   SearchUpdateMessageSchema,
-  SearchUnsubMessageSchema
+  SearchUnsubMessageSchema,
+  // Phase 14.2: Distributed Live Subscriptions (cluster-internal)
+  ClusterSubRegisterMessageSchema,
+  ClusterSubAckMessageSchema,
+  ClusterSubUpdateMessageSchema,
+  ClusterSubUnregisterMessageSchema
 ]);
+var ClusterSearchReqPayloadSchema = z3.object({
+  /** Unique request ID for correlation */
+  requestId: z3.string(),
+  /** Map name to search */
+  mapName: z3.string(),
+  /** Search query text */
+  query: z3.string(),
+  /** Search options */
+  options: z3.object({
+    /** Maximum results per node (for Top-K) */
+    limit: z3.number().int().positive().max(1e3),
+    /** Minimum score threshold */
+    minScore: z3.number().optional(),
+    /** Fields to boost */
+    boost: z3.record(z3.string(), z3.number()).optional(),
+    /** Include matched terms in response */
+    includeMatchedTerms: z3.boolean().optional(),
+    /** For cursor-based pagination: return results after this score */
+    afterScore: z3.number().optional(),
+    /** For cursor-based pagination: return results after this key (tie-breaking) */
+    afterKey: z3.string().optional()
+  }),
+  /** Timeout in milliseconds */
+  timeoutMs: z3.number().int().positive().optional()
+});
+var ClusterSearchReqMessageSchema = z3.object({
+  type: z3.literal("CLUSTER_SEARCH_REQ"),
+  payload: ClusterSearchReqPayloadSchema
+});
+var ClusterSearchRespPayloadSchema = z3.object({
+  /** Correlates to requestId */
+  requestId: z3.string(),
+  /** Node that produced these results */
+  nodeId: z3.string(),
+  /** Search results with scores */
+  results: z3.array(z3.object({
+    key: z3.string(),
+    value: z3.unknown(),
+    score: z3.number(),
+    matchedTerms: z3.array(z3.string()).optional()
+  })),
+  /** Total matching documents on this node (for pagination) */
+  totalHits: z3.number().int().nonnegative(),
+  /** Execution time on this node in ms (for monitoring) */
+  executionTimeMs: z3.number().nonnegative(),
+  /** Error if search failed on this node */
+  error: z3.string().optional()
+});
+var ClusterSearchRespMessageSchema = z3.object({
+  type: z3.literal("CLUSTER_SEARCH_RESP"),
+  payload: ClusterSearchRespPayloadSchema
+});
+var ClusterSearchSubscribePayloadSchema = z3.object({
+  subscriptionId: z3.string(),
+  mapName: z3.string(),
+  query: z3.string(),
+  options: SearchOptionsSchema.optional()
+});
+var ClusterSearchSubscribeMessageSchema = z3.object({
+  type: z3.literal("CLUSTER_SEARCH_SUBSCRIBE"),
+  payload: ClusterSearchSubscribePayloadSchema
+});
+var ClusterSearchUnsubscribePayloadSchema = z3.object({
+  subscriptionId: z3.string()
+});
+var ClusterSearchUnsubscribeMessageSchema = z3.object({
+  type: z3.literal("CLUSTER_SEARCH_UNSUBSCRIBE"),
+  payload: ClusterSearchUnsubscribePayloadSchema
+});
+var ClusterSearchUpdatePayloadSchema = z3.object({
+  subscriptionId: z3.string(),
+  nodeId: z3.string(),
+  key: z3.string(),
+  value: z3.unknown(),
+  score: z3.number(),
+  matchedTerms: z3.array(z3.string()).optional(),
+  type: SearchUpdateTypeSchema
+});
+var ClusterSearchUpdateMessageSchema = z3.object({
+  type: z3.literal("CLUSTER_SEARCH_UPDATE"),
+  payload: ClusterSearchUpdatePayloadSchema
+});
 
 // src/types/WriteConcern.ts
 var WriteConcern = /* @__PURE__ */ ((WriteConcern2) => {
@@ -6029,7 +6226,7 @@ var QueryOptimizer = class {
    */
   optimizeWithOptions(query, options) {
     const basePlan = this.optimize(query);
-    if (!options.sort && options.limit === void 0 && options.offset === void 0) {
+    if (!options.sort && options.limit === void 0 && options.cursor === void 0) {
       return basePlan;
     }
     let indexedSort = false;
@@ -6051,7 +6248,8 @@ var QueryOptimizer = class {
       indexedSort,
       sort: sortField && sortDirection ? { field: sortField, direction: sortDirection } : void 0,
       limit: options.limit,
-      offset: options.offset
+      cursor: options.cursor
+      // Phase 14.1: replaces offset
     };
   }
   /**
@@ -8171,6 +8369,264 @@ var ReciprocalRankFusion = class {
   }
 };
 
+// src/utils/base64url.ts
+function encodeBase64Url(str) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(str, "utf8").toString("base64url");
+  }
+  const base64 = btoa(unescape(encodeURIComponent(str)));
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeBase64Url(encoded) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(encoded, "base64url").toString("utf8");
+  }
+  let base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  const pad = base64.length % 4;
+  if (pad) {
+    base64 += "=".repeat(4 - pad);
+  }
+  return decodeURIComponent(escape(atob(base64)));
+}
+
+// src/utils/compare.ts
+function compareValues(a, b) {
+  if (a == null && b == null) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "number" && typeof b === "number") {
+    return a - b;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() - b.getTime();
+  }
+  if (typeof a === "string" && typeof b === "string") {
+    const dateA = Date.parse(a);
+    const dateB = Date.parse(b);
+    if (!isNaN(dateA) && !isNaN(dateB)) {
+      return dateA - dateB;
+    }
+    return a.localeCompare(b);
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return a === b ? 0 : a ? 1 : -1;
+  }
+  return String(a).localeCompare(String(b));
+}
+
+// src/query/QueryCursor.ts
+var DEFAULT_QUERY_CURSOR_MAX_AGE_MS = 10 * 60 * 1e3;
+var QueryCursor = class {
+  /**
+   * Encode cursor data to an opaque base64url string.
+   *
+   * @param data - Cursor data to encode
+   * @returns Opaque cursor string
+   */
+  static encode(data) {
+    const json = JSON.stringify(data);
+    return encodeBase64Url(json);
+  }
+  /**
+   * Decode cursor string back to data.
+   *
+   * @param cursor - Opaque cursor string
+   * @returns Decoded cursor data, or null if invalid
+   */
+  static decode(cursor) {
+    try {
+      const json = decodeBase64Url(cursor);
+      const data = JSON.parse(json);
+      if (typeof data !== "object" || typeof data.nodeValues !== "object" || typeof data.nodeKeys !== "object" || typeof data.sortField !== "string" || data.sortDirection !== "asc" && data.sortDirection !== "desc" || typeof data.predicateHash !== "number" || typeof data.sortHash !== "number" || typeof data.timestamp !== "number") {
+        return null;
+      }
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Create a cursor from query results.
+   *
+   * The cursor captures the last seen position for each node that contributed
+   * results, enabling efficient resumption in the next page request.
+   *
+   * @param results - Array of results with sort values and optional node tracking
+   * @param sort - Sort configuration (single field only for v1)
+   * @param predicate - Query predicate (for validation)
+   * @returns Encoded cursor string
+   */
+  static fromResults(results, sort, predicate) {
+    const nodeValues = {};
+    const nodeKeys = {};
+    const sortEntries = Object.entries(sort);
+    if (sortEntries.length === 0) {
+      throw new Error("Sort configuration required for cursor pagination");
+    }
+    const [sortField, sortDirection] = sortEntries[0];
+    for (const result of results) {
+      const nodeId = result.nodeId ?? "local";
+      nodeValues[nodeId] = result.sortValue;
+      nodeKeys[nodeId] = result.key;
+    }
+    const data = {
+      nodeValues,
+      nodeKeys,
+      sortField,
+      sortDirection,
+      predicateHash: hashObject(predicate ?? null),
+      sortHash: hashObject(sort),
+      timestamp: Date.now()
+    };
+    return this.encode(data);
+  }
+  /**
+   * Create a cursor from the last result only.
+   * Useful for local-only queries.
+   *
+   * @param lastResult - The last result in the current page
+   * @param sort - Sort configuration
+   * @param predicate - Query predicate
+   * @returns Encoded cursor string
+   */
+  static fromLastResult(lastResult, sort, predicate) {
+    return this.fromResults([lastResult], sort, predicate);
+  }
+  /**
+   * Validate that a cursor is valid for the given query.
+   *
+   * Checks:
+   * 1. Predicate hash matches (cursor was created for this query)
+   * 2. Sort hash matches (sort configuration unchanged)
+   * 3. Cursor is not expired
+   *
+   * @param cursor - Decoded cursor data
+   * @param predicate - Query predicate to validate against
+   * @param sort - Sort configuration to validate against
+   * @param options - Validation options
+   * @returns true if cursor is valid
+   */
+  static isValid(cursor, predicate, sort, options) {
+    const maxAge = options?.maxAgeMs ?? DEFAULT_QUERY_CURSOR_MAX_AGE_MS;
+    if (cursor.predicateHash !== hashObject(predicate ?? null)) {
+      return false;
+    }
+    if (cursor.sortHash !== hashObject(sort)) {
+      return false;
+    }
+    if (Date.now() - cursor.timestamp > maxAge) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Get the cursor position for a specific node.
+   *
+   * @param cursor - Decoded cursor data
+   * @param nodeId - Node ID to get position for (defaults to 'local')
+   * @returns Position info or null if node not in cursor
+   */
+  static getNodePosition(cursor, nodeId = "local") {
+    if (!(nodeId in cursor.nodeValues)) {
+      return null;
+    }
+    return {
+      afterValue: cursor.nodeValues[nodeId],
+      afterKey: cursor.nodeKeys[nodeId]
+    };
+  }
+  /**
+   * Check if a result should be included based on cursor position.
+   *
+   * For ASC sort: value > cursorValue OR (value === cursorValue AND key > cursorKey)
+   * For DESC sort: value < cursorValue OR (value === cursorValue AND key > cursorKey)
+   *
+   * @param result - Result to check
+   * @param cursor - Decoded cursor data
+   * @returns true if result should be included (is after cursor)
+   */
+  static isAfterCursor(result, cursor) {
+    const nodeId = result.nodeId ?? "local";
+    const position = this.getNodePosition(cursor, nodeId);
+    if (!position) {
+      return true;
+    }
+    const cmp = this.compareValues(result.sortValue, position.afterValue);
+    if (cursor.sortDirection === "asc") {
+      if (cmp > 0) return true;
+      if (cmp === 0 && result.key > position.afterKey) return true;
+    } else {
+      if (cmp < 0) return true;
+      if (cmp === 0 && result.key > position.afterKey) return true;
+    }
+    return false;
+  }
+  /**
+   * Compare two values with type-aware comparison.
+   * Delegates to shared compareValues utility.
+   *
+   * @param a - First value
+   * @param b - Second value
+   * @returns Negative if a < b, 0 if equal, positive if a > b
+   */
+  static compareValues(a, b) {
+    return compareValues(a, b);
+  }
+  /**
+   * Merge multiple cursors into one.
+   * Useful when combining results from multiple sub-queries or nodes.
+   *
+   * Keeps the furthest position for each node.
+   *
+   * @param cursors - Array of decoded cursor data
+   * @param sort - Sort configuration
+   * @param predicate - Query predicate
+   * @returns New merged cursor
+   */
+  static merge(cursors, sort, predicate) {
+    const nodeValues = {};
+    const nodeKeys = {};
+    const sortEntries = Object.entries(sort);
+    const [sortField, sortDirection] = sortEntries[0];
+    for (const cursor of cursors) {
+      for (const nodeId of Object.keys(cursor.nodeValues)) {
+        const existingValue = nodeValues[nodeId];
+        const newValue = cursor.nodeValues[nodeId];
+        if (existingValue === void 0) {
+          nodeValues[nodeId] = newValue;
+          nodeKeys[nodeId] = cursor.nodeKeys[nodeId];
+        } else {
+          const cmp = this.compareValues(newValue, existingValue);
+          const isFurther = sortDirection === "asc" ? cmp > 0 || cmp === 0 && cursor.nodeKeys[nodeId] > nodeKeys[nodeId] : cmp < 0 || cmp === 0 && cursor.nodeKeys[nodeId] > nodeKeys[nodeId];
+          if (isFurther) {
+            nodeValues[nodeId] = newValue;
+            nodeKeys[nodeId] = cursor.nodeKeys[nodeId];
+          }
+        }
+      }
+    }
+    return {
+      nodeValues,
+      nodeKeys,
+      sortField,
+      sortDirection,
+      predicateHash: hashObject(predicate ?? null),
+      sortHash: hashObject(sort),
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Extract sort value from a record for cursor generation.
+   *
+   * @param record - Record to extract sort value from
+   * @param sortField - Field to extract
+   * @returns Sort value
+   */
+  static extractSortValue(record, sortField) {
+    return record[sortField];
+  }
+};
+
 // src/IndexedLWWMap.ts
 var IndexedLWWMap = class extends LWWMap {
   constructor(hlc, options = {}) {
@@ -10746,6 +11202,179 @@ var IndexedORMap = class extends ORMap {
     return null;
   }
 };
+
+// src/search/SearchCursor.ts
+var DEFAULT_CURSOR_MAX_AGE_MS = 5 * 60 * 1e3;
+var SearchCursor = class {
+  /**
+   * Encode cursor data to an opaque base64url string.
+   *
+   * @param data - Cursor data to encode
+   * @returns Opaque cursor string
+   */
+  static encode(data) {
+    const json = JSON.stringify(data);
+    return encodeBase64Url(json);
+  }
+  /**
+   * Decode cursor string back to data.
+   *
+   * @param cursor - Opaque cursor string
+   * @returns Decoded cursor data, or null if invalid
+   */
+  static decode(cursor) {
+    try {
+      const json = decodeBase64Url(cursor);
+      const data = JSON.parse(json);
+      if (typeof data !== "object" || typeof data.nodeScores !== "object" || typeof data.nodeKeys !== "object" || typeof data.queryHash !== "number" || typeof data.timestamp !== "number") {
+        return null;
+      }
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Create a cursor from the last results of a search.
+   *
+   * The cursor captures the last seen position for each node that contributed
+   * results, enabling efficient resumption in the next page request.
+   *
+   * @param results - Array of results with node tracking
+   * @param query - Original query string (for validation)
+   * @returns Encoded cursor string
+   */
+  static fromResults(results, query) {
+    const nodeScores = {};
+    const nodeKeys = {};
+    for (const result of results) {
+      nodeScores[result.nodeId] = result.score;
+      nodeKeys[result.nodeId] = result.key;
+    }
+    const data = {
+      nodeScores,
+      nodeKeys,
+      queryHash: hashString(query),
+      timestamp: Date.now()
+    };
+    return this.encode(data);
+  }
+  /**
+   * Create a cursor from the last result only.
+   * Useful when you only have the final merged result.
+   *
+   * @param lastResult - The last result in the current page
+   * @param query - Original query string
+   * @returns Encoded cursor string
+   */
+  static fromLastResult(lastResult, query) {
+    return this.fromResults([lastResult], query);
+  }
+  /**
+   * Generate a hash for a query string.
+   * Used to validate that cursor matches the current query.
+   *
+   * @param query - Query string to hash
+   * @returns Numeric hash
+   */
+  static hashQuery(query) {
+    return hashString(query);
+  }
+  /**
+   * Validate that a cursor is valid for the given query.
+   *
+   * Checks:
+   * 1. Query hash matches (cursor was created for this query)
+   * 2. Cursor is not expired
+   *
+   * @param cursor - Decoded cursor data
+   * @param query - Query string to validate against
+   * @param maxAgeMs - Maximum cursor age in milliseconds (default: 5 minutes)
+   * @returns true if cursor is valid
+   */
+  static isValid(cursor, query, maxAgeMs = DEFAULT_CURSOR_MAX_AGE_MS) {
+    if (cursor.queryHash !== hashString(query)) {
+      return false;
+    }
+    if (Date.now() - cursor.timestamp > maxAgeMs) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Get the cursor position for a specific node.
+   *
+   * @param cursor - Decoded cursor data
+   * @param nodeId - Node ID to get position for
+   * @returns Position info or null if node not in cursor
+   */
+  static getNodePosition(cursor, nodeId) {
+    if (!(nodeId in cursor.nodeScores)) {
+      return null;
+    }
+    return {
+      afterScore: cursor.nodeScores[nodeId],
+      afterKey: cursor.nodeKeys[nodeId]
+    };
+  }
+  /**
+   * Check if a result should be included based on cursor position.
+   *
+   * Results are ordered by score descending, then key ascending for tie-breaking.
+   * A result should be included if it comes AFTER the cursor position:
+   * - score < cursorScore, OR
+   * - score === cursorScore AND key > cursorKey
+   *
+   * @param result - Result to check
+   * @param cursor - Decoded cursor data
+   * @returns true if result should be included (is after cursor)
+   */
+  static isAfterCursor(result, cursor) {
+    const position = this.getNodePosition(cursor, result.nodeId);
+    if (!position) {
+      return true;
+    }
+    if (result.score < position.afterScore) {
+      return true;
+    }
+    if (result.score === position.afterScore && result.key > position.afterKey) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Merge multiple cursors into one.
+   * Useful when combining results from multiple sub-queries.
+   *
+   * @param cursors - Array of decoded cursor data
+   * @param query - Original query string
+   * @returns New merged cursor
+   */
+  static merge(cursors, query) {
+    const nodeScores = {};
+    const nodeKeys = {};
+    for (const cursor of cursors) {
+      for (const nodeId of Object.keys(cursor.nodeScores)) {
+        const existingScore = nodeScores[nodeId];
+        const newScore = cursor.nodeScores[nodeId];
+        if (existingScore === void 0 || newScore < existingScore) {
+          nodeScores[nodeId] = newScore;
+          nodeKeys[nodeId] = cursor.nodeKeys[nodeId];
+        } else if (newScore === existingScore) {
+          if (cursor.nodeKeys[nodeId] > nodeKeys[nodeId]) {
+            nodeKeys[nodeId] = cursor.nodeKeys[nodeId];
+          }
+        }
+      }
+    }
+    return {
+      nodeScores,
+      nodeKeys,
+      queryHash: hashString(query),
+      timestamp: Date.now()
+    };
+  }
+};
 export {
   AuthMessageSchema,
   BM25Scorer,
@@ -10754,6 +11383,24 @@ export {
   BuiltInResolvers,
   ClientOpMessageSchema,
   ClientOpSchema,
+  ClusterSearchReqMessageSchema,
+  ClusterSearchReqPayloadSchema,
+  ClusterSearchRespMessageSchema,
+  ClusterSearchRespPayloadSchema,
+  ClusterSearchSubscribeMessageSchema,
+  ClusterSearchSubscribePayloadSchema,
+  ClusterSearchUnsubscribeMessageSchema,
+  ClusterSearchUnsubscribePayloadSchema,
+  ClusterSearchUpdateMessageSchema,
+  ClusterSearchUpdatePayloadSchema,
+  ClusterSubAckMessageSchema,
+  ClusterSubAckPayloadSchema,
+  ClusterSubRegisterMessageSchema,
+  ClusterSubRegisterPayloadSchema,
+  ClusterSubUnregisterMessageSchema,
+  ClusterSubUnregisterPayloadSchema,
+  ClusterSubUpdateMessageSchema,
+  ClusterSubUpdatePayloadSchema,
   ConflictResolverDefSchema,
   ConflictResolverSchema,
   ConsistencyLevel,
@@ -10761,13 +11408,16 @@ export {
   CounterResponseSchema,
   CounterSyncSchema,
   CounterUpdateSchema,
+  CursorStatusSchema,
   DEFAULT_BACKUP_COUNT,
   DEFAULT_CIRCUIT_BREAKER_CONFIG,
   DEFAULT_CONNECTION_POOL_CONFIG,
+  DEFAULT_CURSOR_MAX_AGE_MS,
   DEFAULT_EVENT_JOURNAL_CONFIG,
   DEFAULT_MIGRATION_CONFIG,
   DEFAULT_PARTITION_ROUTER_CONFIG,
   DEFAULT_PROCESSOR_RATE_LIMITS,
+  DEFAULT_QUERY_CURSOR_MAX_AGE_MS,
   DEFAULT_REPLICATION_CONFIG,
   DEFAULT_RESOLVER_RATE_LIMITS,
   DEFAULT_STOP_WORDS,
@@ -10845,7 +11495,10 @@ export {
   PredicateNodeSchema,
   PredicateOpSchema,
   Predicates,
+  QueryCursor,
   QueryOptimizer,
+  QueryRespMessageSchema,
+  QueryRespPayloadSchema,
   QuerySchema,
   QuerySubMessageSchema,
   QueryUnsubMessageSchema,
@@ -10854,6 +11507,7 @@ export {
   RegisterResolverRequestSchema,
   RegisterResolverResponseSchema,
   Ringbuffer,
+  SearchCursor,
   SearchMessageSchema,
   SearchOptionsSchema,
   SearchPayloadSchema,
@@ -10896,15 +11550,19 @@ export {
   combineHashes,
   compareHLCTimestamps,
   compareTimestamps,
+  compareValues,
   createFieldComparator,
   createPredicateMatcher,
+  decodeBase64Url,
   deepMerge,
   deserialize,
   disableNativeHash,
+  encodeBase64Url,
   evaluatePredicate,
   getHighestWriteConcernLevel,
   hashORMapEntry,
   hashORMapRecord,
+  hashObject,
   hashString,
   isLogicalQuery,
   isSimpleQuery,