@topgunbuild/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,906 @@
+// src/HLC.ts
+var _HLC = class _HLC {
+  constructor(nodeId) {
+    this.nodeId = nodeId;
+    this.lastMillis = 0;
+    this.lastCounter = 0;
+  }
+  get getNodeId() {
+    return this.nodeId;
+  }
+  /**
+   * Generates a new unique timestamp for a local event.
+   * Ensures monotonicity: always greater than any previously generated or received timestamp.
+   */
+  now() {
+    const systemTime = Date.now();
+    if (systemTime > this.lastMillis) {
+      this.lastMillis = systemTime;
+      this.lastCounter = 0;
+    } else {
+      this.lastCounter++;
+    }
+    return {
+      millis: this.lastMillis,
+      counter: this.lastCounter,
+      nodeId: this.nodeId
+    };
+  }
+  /**
+   * Updates the local clock based on a received remote timestamp.
+   * Must be called whenever a message/event is received from another node.
+   */
+  update(remote) {
+    const systemTime = Date.now();
+    if (remote.millis > systemTime + _HLC.MAX_DRIFT) {
+      console.warn(`Clock drift detected: Remote time ${remote.millis} is far ahead of local ${systemTime}`);
+    }
+    const maxMillis = Math.max(this.lastMillis, systemTime, remote.millis);
+    if (maxMillis === this.lastMillis && maxMillis === remote.millis) {
+      this.lastCounter = Math.max(this.lastCounter, remote.counter) + 1;
+    } else if (maxMillis === this.lastMillis) {
+      this.lastCounter++;
+    } else if (maxMillis === remote.millis) {
+      this.lastCounter = remote.counter + 1;
+    } else {
+      this.lastCounter = 0;
+    }
+    this.lastMillis = maxMillis;
+  }
+  /**
+   * Compares two timestamps.
+   * Returns -1 if a < b, 1 if a > b, 0 if equal.
+   */
+  static compare(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);
+  }
+  /**
+   * Serializes timestamp to a string representation (e.g., for storage/network).
+   * Format: "<millis>:<counter>:<nodeId>"
+   */
+  static toString(ts) {
+    return `${ts.millis}:${ts.counter}:${ts.nodeId}`;
+  }
+  /**
+   * Parses a string representation back to a Timestamp object.
+   */
+  static parse(str) {
+    const parts = str.split(":");
+    if (parts.length !== 3) {
+      throw new Error(`Invalid timestamp format: ${str}`);
+    }
+    return {
+      millis: parseInt(parts[0], 10),
+      counter: parseInt(parts[1], 10),
+      nodeId: parts[2]
+    };
+  }
+};
+// Max allowable drift in milliseconds (1 minute)
+_HLC.MAX_DRIFT = 6e4;
+var HLC = _HLC;
+
+// src/utils/hash.ts
+function hashString(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function combineHashes(hashes) {
+  let result = 0;
+  for (const h of hashes) {
+    result = result + h | 0;
+  }
+  return result >>> 0;
+}
+
+// src/MerkleTree.ts
+var MerkleTree = class {
+  constructor(records = /* @__PURE__ */ new Map(), depth = 3) {
+    this.depth = depth;
+    this.root = { hash: 0, children: {} };
+    for (const [key, record] of records) {
+      this.update(key, record);
+    }
+  }
+  /**
+   * Incrementally updates the Merkle Tree with a single record.
+   * @param key The key of the record
+   * @param record The record (value + timestamp)
+   */
+  update(key, record) {
+    const itemHash = hashString(`${key}:${record.timestamp.millis}:${record.timestamp.counter}:${record.timestamp.nodeId}`);
+    const pathHash = hashString(key).toString(16).padStart(8, "0");
+    this.updateNode(this.root, key, itemHash, pathHash, 0);
+  }
+  /**
+   * Removes a key from the Merkle Tree.
+   * Necessary for Garbage Collection of tombstones.
+   */
+  remove(key) {
+    const pathHash = hashString(key).toString(16).padStart(8, "0");
+    this.removeNode(this.root, key, pathHash, 0);
+  }
+  removeNode(node, key, pathHash, level) {
+    if (level >= this.depth) {
+      if (node.entries) {
+        node.entries.delete(key);
+        let h2 = 0;
+        for (const val of node.entries.values()) {
+          h2 = h2 + val | 0;
+        }
+        node.hash = h2 >>> 0;
+      }
+      return node.hash;
+    }
+    const bucketChar = pathHash[level];
+    if (node.children && node.children[bucketChar]) {
+      const childHash = this.removeNode(node.children[bucketChar], key, pathHash, level + 1);
+    }
+    let h = 0;
+    if (node.children) {
+      for (const child of Object.values(node.children)) {
+        h = h + child.hash | 0;
+      }
+    }
+    node.hash = h >>> 0;
+    return node.hash;
+  }
+  updateNode(node, key, itemHash, pathHash, level) {
+    if (level >= this.depth) {
+      if (!node.entries) node.entries = /* @__PURE__ */ new Map();
+      node.entries.set(key, itemHash);
+      let h2 = 0;
+      for (const val of node.entries.values()) {
+        h2 = h2 + val | 0;
+      }
+      node.hash = h2 >>> 0;
+      return node.hash;
+    }
+    const bucketChar = pathHash[level];
+    if (!node.children) node.children = {};
+    if (!node.children[bucketChar]) {
+      node.children[bucketChar] = { hash: 0 };
+    }
+    this.updateNode(node.children[bucketChar], key, itemHash, pathHash, level + 1);
+    let h = 0;
+    for (const child of Object.values(node.children)) {
+      h = h + child.hash | 0;
+    }
+    node.hash = h >>> 0;
+    return node.hash;
+  }
+  getRootHash() {
+    return this.root.hash;
+  }
+  getNode(path) {
+    let current = this.root;
+    for (const char of path) {
+      if (!current.children || !current.children[char]) {
+        return void 0;
+      }
+      current = current.children[char];
+    }
+    return current;
+  }
+  /**
+   * Returns the hashes of the children at the given path.
+   * Used by the client/server to compare buckets.
+   */
+  getBuckets(path) {
+    const node = this.getNode(path);
+    if (!node || !node.children) return {};
+    const result = {};
+    for (const [key, child] of Object.entries(node.children)) {
+      result[key] = child.hash;
+    }
+    return result;
+  }
+  /**
+   * For a leaf node (bucket), returns the actual keys it contains.
+   * Used to request specific keys when a bucket differs.
+   */
+  getKeysInBucket(path) {
+    const node = this.getNode(path);
+    if (!node || !node.entries) return [];
+    return Array.from(node.entries.keys());
+  }
+};
+
+// src/LWWMap.ts
+var LWWMap = class {
+  constructor(hlc) {
+    this.listeners = [];
+    this.hlc = hlc;
+    this.data = /* @__PURE__ */ new Map();
+    this.merkleTree = new MerkleTree();
+  }
+  onChange(callback) {
+    this.listeners.push(callback);
+    return () => {
+      this.listeners = this.listeners.filter((cb) => cb !== callback);
+    };
+  }
+  notify() {
+    this.listeners.forEach((cb) => cb());
+  }
+  getMerkleTree() {
+    return this.merkleTree;
+  }
+  get size() {
+    return this.data.size;
+  }
+  /**
+   * Sets a value for a key.
+   * Generates a new timestamp using the local HLC.
+   */
+  set(key, value, ttlMs) {
+    const timestamp = this.hlc.now();
+    const record = { value, timestamp };
+    if (ttlMs !== void 0) {
+      if (typeof ttlMs !== "number" || ttlMs <= 0 || !Number.isFinite(ttlMs)) {
+        throw new Error("TTL must be a positive finite number");
+      }
+      record.ttlMs = ttlMs;
+    }
+    this.data.set(key, record);
+    this.merkleTree.update(String(key), record);
+    this.notify();
+    return record;
+  }
+  /**
+   * Retrieves the value for a key.
+   * Returns undefined if key doesn't exist, is a tombstone, or is expired.
+   */
+  get(key) {
+    const record = this.data.get(key);
+    if (!record || record.value === null) {
+      return void 0;
+    }
+    if (record.ttlMs) {
+      const now = Date.now();
+      if (record.timestamp.millis + record.ttlMs < now) {
+        return void 0;
+      }
+    }
+    return record.value;
+  }
+  /**
+   * Returns the full record (including timestamp).
+   * Useful for synchronization.
+   */
+  getRecord(key) {
+    return this.data.get(key);
+  }
+  /**
+   * Removes a key (creates a tombstone).
+   */
+  remove(key) {
+    const timestamp = this.hlc.now();
+    const tombstone = { value: null, timestamp };
+    this.data.set(key, tombstone);
+    this.merkleTree.update(String(key), tombstone);
+    this.notify();
+    return tombstone;
+  }
+  /**
+   * Merges a record from a remote source.
+   * Returns true if the local state was updated.
+   */
+  merge(key, remoteRecord) {
+    this.hlc.update(remoteRecord.timestamp);
+    const localRecord = this.data.get(key);
+    if (!localRecord || HLC.compare(remoteRecord.timestamp, localRecord.timestamp) > 0) {
+      this.data.set(key, remoteRecord);
+      this.merkleTree.update(String(key), remoteRecord);
+      this.notify();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Garbage Collection: Prunes tombstones older than the specified timestamp.
+   * Only removes records that are tombstones (deleted) AND older than the threshold.
+   * 
+   * @param olderThan The timestamp threshold. Tombstones older than this will be removed.
+   * @returns The number of tombstones removed.
+   */
+  prune(olderThan) {
+    const removedKeys = [];
+    for (const [key, record] of this.data.entries()) {
+      if (record.value === null) {
+        if (HLC.compare(record.timestamp, olderThan) < 0) {
+          this.data.delete(key);
+          this.merkleTree.remove(String(key));
+          removedKeys.push(key);
+        }
+      }
+    }
+    if (removedKeys.length > 0) {
+      this.notify();
+    }
+    return removedKeys;
+  }
+  /**
+   * Clears all data and tombstones.
+   * Resets the MerkleTree.
+   */
+  clear() {
+    this.data.clear();
+    this.merkleTree = new MerkleTree();
+    this.notify();
+  }
+  /**
+   * Returns an iterator over all non-deleted entries.
+   */
+  entries() {
+    const iterator = this.data.entries();
+    const now = Date.now();
+    return {
+      [Symbol.iterator]() {
+        return this;
+      },
+      next: () => {
+        let result = iterator.next();
+        while (!result.done) {
+          const [key, record] = result.value;
+          if (record.value !== null) {
+            if (record.ttlMs && record.timestamp.millis + record.ttlMs < now) {
+              result = iterator.next();
+              continue;
+            }
+            return { value: [key, record.value], done: false };
+          }
+          result = iterator.next();
+        }
+        return { value: void 0, done: true };
+      }
+    };
+  }
+  /**
+   * Returns all keys (including tombstones).
+   */
+  allKeys() {
+    return this.data.keys();
+  }
+};
+
+// src/ORMap.ts
+var ORMap = class {
+  constructor(hlc) {
+    this.listeners = [];
+    this.hlc = hlc;
+    this.items = /* @__PURE__ */ new Map();
+    this.tombstones = /* @__PURE__ */ new Set();
+  }
+  onChange(callback) {
+    this.listeners.push(callback);
+    return () => {
+      this.listeners = this.listeners.filter((cb) => cb !== callback);
+    };
+  }
+  notify() {
+    this.listeners.forEach((cb) => cb());
+  }
+  get size() {
+    return this.items.size;
+  }
+  get totalRecords() {
+    let count = 0;
+    for (const keyMap of this.items.values()) {
+      count += keyMap.size;
+    }
+    return count;
+  }
+  /**
+   * Adds a value to the set associated with the key.
+   * Generates a unique tag for this specific addition.
+   */
+  add(key, value, ttlMs) {
+    const timestamp = this.hlc.now();
+    const tag = HLC.toString(timestamp);
+    const record = {
+      value,
+      timestamp,
+      tag
+    };
+    if (ttlMs !== void 0) {
+      if (typeof ttlMs !== "number" || ttlMs <= 0 || !Number.isFinite(ttlMs)) {
+        throw new Error("TTL must be a positive finite number");
+      }
+      record.ttlMs = ttlMs;
+    }
+    let keyMap = this.items.get(key);
+    if (!keyMap) {
+      keyMap = /* @__PURE__ */ new Map();
+      this.items.set(key, keyMap);
+    }
+    keyMap.set(tag, record);
+    this.notify();
+    return record;
+  }
+  /**
+   * Removes a specific value from the set associated with the key.
+   * Marks all *currently observed* instances of this value as removed (tombstones).
+   * Returns the list of tags that were removed (useful for sync).
+   */
+  remove(key, value) {
+    const keyMap = this.items.get(key);
+    if (!keyMap) return [];
+    const tagsToRemove = [];
+    for (const [tag, record] of keyMap.entries()) {
+      if (record.value === value) {
+        tagsToRemove.push(tag);
+      }
+    }
+    for (const tag of tagsToRemove) {
+      this.tombstones.add(tag);
+      keyMap.delete(tag);
+    }
+    if (keyMap.size === 0) {
+      this.items.delete(key);
+    }
+    this.notify();
+    return tagsToRemove;
+  }
+  /**
+   * Clears all data and tombstones.
+   */
+  clear() {
+    this.items.clear();
+    this.tombstones.clear();
+    this.notify();
+  }
+  /**
+   * Returns all active values for a key.
+   * Filters out expired records.
+   */
+  get(key) {
+    const keyMap = this.items.get(key);
+    if (!keyMap) return [];
+    const values = [];
+    const now = Date.now();
+    for (const [tag, record] of keyMap.entries()) {
+      if (!this.tombstones.has(tag)) {
+        if (record.ttlMs && record.timestamp.millis + record.ttlMs < now) {
+          continue;
+        }
+        values.push(record.value);
+      }
+    }
+    return values;
+  }
+  /**
+   * Returns all active records for a key.
+   * Useful for persistence and sync.
+   * Filters out expired records.
+   */
+  getRecords(key) {
+    const keyMap = this.items.get(key);
+    if (!keyMap) return [];
+    const records = [];
+    const now = Date.now();
+    for (const [tag, record] of keyMap.entries()) {
+      if (!this.tombstones.has(tag)) {
+        if (record.ttlMs && record.timestamp.millis + record.ttlMs < now) {
+          continue;
+        }
+        records.push(record);
+      }
+    }
+    return records;
+  }
+  /**
+   * Returns all tombstone tags.
+   */
+  getTombstones() {
+    return Array.from(this.tombstones);
+  }
+  /**
+   * Applies a record from a remote source (Sync).
+   */
+  apply(key, record) {
+    if (this.tombstones.has(record.tag)) return;
+    let keyMap = this.items.get(key);
+    if (!keyMap) {
+      keyMap = /* @__PURE__ */ new Map();
+      this.items.set(key, keyMap);
+    }
+    keyMap.set(record.tag, record);
+    this.hlc.update(record.timestamp);
+    this.notify();
+  }
+  /**
+   * Applies a tombstone (deletion) from a remote source.
+   */
+  applyTombstone(tag) {
+    this.tombstones.add(tag);
+    for (const [key, keyMap] of this.items) {
+      if (keyMap.has(tag)) {
+        keyMap.delete(tag);
+        if (keyMap.size === 0) this.items.delete(key);
+        break;
+      }
+    }
+    this.notify();
+  }
+  /**
+   * Merges state from another ORMap.
+   * - Adds all new tombstones from 'other'.
+   * - Adds all new items from 'other' that are not in tombstones.
+   * - Updates HLC with observed timestamps.
+   */
+  merge(other) {
+    for (const tag of other.tombstones) {
+      this.tombstones.add(tag);
+    }
+    for (const [key, otherKeyMap] of other.items) {
+      let localKeyMap = this.items.get(key);
+      if (!localKeyMap) {
+        localKeyMap = /* @__PURE__ */ new Map();
+        this.items.set(key, localKeyMap);
+      }
+      for (const [tag, record] of otherKeyMap) {
+        if (!this.tombstones.has(tag)) {
+          if (!localKeyMap.has(tag)) {
+            localKeyMap.set(tag, record);
+          }
+          this.hlc.update(record.timestamp);
+        }
+      }
+    }
+    for (const [key, localKeyMap] of this.items) {
+      for (const tag of localKeyMap.keys()) {
+        if (this.tombstones.has(tag)) {
+          localKeyMap.delete(tag);
+        }
+      }
+      if (localKeyMap.size === 0) {
+        this.items.delete(key);
+      }
+    }
+    this.notify();
+  }
+  /**
+   * Garbage Collection: Prunes tombstones older than the specified timestamp.
+   */
+  prune(olderThan) {
+    const removedTags = [];
+    for (const tag of this.tombstones) {
+      try {
+        const timestamp = HLC.parse(tag);
+        if (HLC.compare(timestamp, olderThan) < 0) {
+          this.tombstones.delete(tag);
+          removedTags.push(tag);
+        }
+      } catch (e) {
+      }
+    }
+    return removedTags;
+  }
+};
+
+// src/serializer.ts
+import { encode, decode } from "@msgpack/msgpack";
+function serialize(data) {
+  return encode(data);
+}
+function deserialize(data) {
+  return decode(data);
+}
+
+// src/predicate.ts
+var Predicates = class {
+  static equal(attribute, value) {
+    return { op: "eq", attribute, value };
+  }
+  static notEqual(attribute, value) {
+    return { op: "neq", attribute, value };
+  }
+  static greaterThan(attribute, value) {
+    return { op: "gt", attribute, value };
+  }
+  static greaterThanOrEqual(attribute, value) {
+    return { op: "gte", attribute, value };
+  }
+  static lessThan(attribute, value) {
+    return { op: "lt", attribute, value };
+  }
+  static lessThanOrEqual(attribute, value) {
+    return { op: "lte", attribute, value };
+  }
+  static like(attribute, pattern) {
+    return { op: "like", attribute, value: pattern };
+  }
+  static regex(attribute, pattern) {
+    return { op: "regex", attribute, value: pattern };
+  }
+  static between(attribute, from, to) {
+    return {
+      op: "and",
+      children: [
+        { op: "gte", attribute, value: from },
+        { op: "lte", attribute, value: to }
+      ]
+    };
+  }
+  static and(...predicates) {
+    return { op: "and", children: predicates };
+  }
+  static or(...predicates) {
+    return { op: "or", children: predicates };
+  }
+  static not(predicate) {
+    return { op: "not", children: [predicate] };
+  }
+};
+function evaluatePredicate(predicate, data) {
+  if (!data) return false;
+  switch (predicate.op) {
+    case "and":
+      return (predicate.children || []).every((p) => evaluatePredicate(p, data));
+    case "or":
+      return (predicate.children || []).some((p) => evaluatePredicate(p, data));
+    case "not": {
+      const child = (predicate.children || [])[0];
+      if (!child) return true;
+      return !evaluatePredicate(child, data);
+    }
+  }
+  if (!predicate.attribute) return false;
+  const value = data[predicate.attribute];
+  const target = predicate.value;
+  switch (predicate.op) {
+    case "eq":
+      return value === target;
+    case "neq":
+      return value !== target;
+    case "gt":
+      return value > target;
+    case "gte":
+      return value >= target;
+    case "lt":
+      return value < target;
+    case "lte":
+      return value <= target;
+    case "like":
+      if (typeof value !== "string" || typeof target !== "string") return false;
+      const pattern = target.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".");
+      return new RegExp(`^${pattern}$`, "i").test(value);
+    case "regex":
+      if (typeof value !== "string" || typeof target !== "string") return false;
+      return new RegExp(target).test(value);
+    default:
+      return false;
+  }
+}
+
+// src/schemas.ts
+import { z } from "zod";
+var TimestampSchema = z.object({
+  millis: z.number(),
+  counter: z.number(),
+  nodeId: z.string()
+});
+var LWWRecordSchema = z.object({
+  value: z.any().nullable(),
+  timestamp: TimestampSchema,
+  ttlMs: z.number().optional()
+});
+var ORMapRecordSchema = z.object({
+  value: z.any(),
+  timestamp: TimestampSchema,
+  tag: z.string(),
+  ttlMs: z.number().optional()
+});
+var PredicateOpSchema = z.enum([
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "like",
+  "regex",
+  "and",
+  "or",
+  "not"
+]);
+var PredicateNodeSchema = z.lazy(() => z.object({
+  op: PredicateOpSchema,
+  attribute: z.string().optional(),
+  value: z.any().optional(),
+  children: z.array(PredicateNodeSchema).optional()
+}));
+var QuerySchema = z.object({
+  where: z.record(z.string(), z.any()).optional(),
+  predicate: PredicateNodeSchema.optional(),
+  sort: z.record(z.string(), z.enum(["asc", "desc"])).optional(),
+  limit: z.number().optional(),
+  offset: z.number().optional()
+});
+var ClientOpSchema = z.object({
+  id: z.string().optional(),
+  mapName: z.string(),
+  key: z.string(),
+  // Permissive opType to match ServerCoordinator behavior logic
+  // It can be 'REMOVE', 'OR_ADD', 'OR_REMOVE' or undefined/other (implies PUT/LWW)
+  opType: z.string().optional(),
+  record: LWWRecordSchema.nullable().optional(),
+  orRecord: ORMapRecordSchema.nullable().optional(),
+  orTag: z.string().nullable().optional()
+});
+var AuthMessageSchema = z.object({
+  type: z.literal("AUTH"),
+  token: z.string()
+});
+var QuerySubMessageSchema = z.object({
+  type: z.literal("QUERY_SUB"),
+  payload: z.object({
+    queryId: z.string(),
+    mapName: z.string(),
+    query: QuerySchema
+  })
+});
+var QueryUnsubMessageSchema = z.object({
+  type: z.literal("QUERY_UNSUB"),
+  payload: z.object({
+    queryId: z.string()
+  })
+});
+var ClientOpMessageSchema = z.object({
+  type: z.literal("CLIENT_OP"),
+  payload: ClientOpSchema
+});
+var OpBatchMessageSchema = z.object({
+  type: z.literal("OP_BATCH"),
+  payload: z.object({
+    ops: z.array(ClientOpSchema)
+  })
+});
+var SyncInitMessageSchema = z.object({
+  type: z.literal("SYNC_INIT"),
+  mapName: z.string(),
+  lastSyncTimestamp: z.number().optional()
+});
+var SyncRespRootMessageSchema = z.object({
+  type: z.literal("SYNC_RESP_ROOT"),
+  payload: z.object({
+    mapName: z.string(),
+    rootHash: z.number(),
+    timestamp: TimestampSchema
+  })
+});
+var SyncRespBucketsMessageSchema = z.object({
+  type: z.literal("SYNC_RESP_BUCKETS"),
+  payload: z.object({
+    mapName: z.string(),
+    path: z.string(),
+    buckets: z.record(z.string(), z.number())
+  })
+});
+var SyncRespLeafMessageSchema = z.object({
+  type: z.literal("SYNC_RESP_LEAF"),
+  payload: z.object({
+    mapName: z.string(),
+    path: z.string(),
+    records: z.array(z.object({
+      key: z.string(),
+      record: LWWRecordSchema
+    }))
+  })
+});
+var MerkleReqBucketMessageSchema = z.object({
+  type: z.literal("MERKLE_REQ_BUCKET"),
+  payload: z.object({
+    mapName: z.string(),
+    path: z.string()
+  })
+});
+var LockRequestSchema = z.object({
+  type: z.literal("LOCK_REQUEST"),
+  payload: z.object({
+    requestId: z.string(),
+    name: z.string(),
+    ttl: z.number().optional()
+  })
+});
+var LockReleaseSchema = z.object({
+  type: z.literal("LOCK_RELEASE"),
+  payload: z.object({
+    requestId: z.string().optional(),
+    name: z.string(),
+    fencingToken: z.number()
+  })
+});
+var TopicSubSchema = z.object({
+  type: z.literal("TOPIC_SUB"),
+  payload: z.object({
+    topic: z.string()
+  })
+});
+var TopicUnsubSchema = z.object({
+  type: z.literal("TOPIC_UNSUB"),
+  payload: z.object({
+    topic: z.string()
+  })
+});
+var TopicPubSchema = z.object({
+  type: z.literal("TOPIC_PUB"),
+  payload: z.object({
+    topic: z.string(),
+    data: z.any()
+  })
+});
+var TopicMessageEventSchema = z.object({
+  type: z.literal("TOPIC_MESSAGE"),
+  payload: z.object({
+    topic: z.string(),
+    data: z.any(),
+    publisherId: z.string().optional(),
+    timestamp: z.number()
+  })
+});
+var MessageSchema = z.discriminatedUnion("type", [
+  AuthMessageSchema,
+  QuerySubMessageSchema,
+  QueryUnsubMessageSchema,
+  ClientOpMessageSchema,
+  OpBatchMessageSchema,
+  SyncInitMessageSchema,
+  SyncRespRootMessageSchema,
+  SyncRespBucketsMessageSchema,
+  SyncRespLeafMessageSchema,
+  MerkleReqBucketMessageSchema,
+  LockRequestSchema,
+  LockReleaseSchema,
+  TopicSubSchema,
+  TopicUnsubSchema,
+  TopicPubSchema
+]);
+export {
+  AuthMessageSchema,
+  ClientOpMessageSchema,
+  ClientOpSchema,
+  HLC,
+  LWWMap,
+  LWWRecordSchema,
+  LockReleaseSchema,
+  LockRequestSchema,
+  MerkleReqBucketMessageSchema,
+  MerkleTree,
+  MessageSchema,
+  ORMap,
+  ORMapRecordSchema,
+  OpBatchMessageSchema,
+  PredicateNodeSchema,
+  PredicateOpSchema,
+  Predicates,
+  QuerySchema,
+  QuerySubMessageSchema,
+  QueryUnsubMessageSchema,
+  SyncInitMessageSchema,
+  SyncRespBucketsMessageSchema,
+  SyncRespLeafMessageSchema,
+  SyncRespRootMessageSchema,
+  TimestampSchema,
+  TopicMessageEventSchema,
+  TopicPubSchema,
+  TopicSubSchema,
+  TopicUnsubSchema,
+  combineHashes,
+  deserialize,
+  evaluatePredicate,
+  hashString,
+  serialize
+};
+//# sourceMappingURL=index.mjs.map