@hanzo/base 0.2.0

package/dist/chunk-5NHFZRMO.js

@@ -0,0 +1,1011 @@
+// src/crdt/sync.ts
+var CRDTSync = class {
+  constructor() {
+    this._ws = null;
+    this._state = "disconnected";
+    this._document = null;
+    this._wsUrl = null;
+    /** Flush interval for batching local ops. */
+    this._flushTimer = null;
+    this._flushIntervalMs = 50;
+    /** Reconnection. */
+    this._reconnectTimer = null;
+    this._reconnectAttempts = 0;
+    this._maxReconnectDelay = 3e4;
+    this._baseReconnectDelay = 500;
+    this._intentionalClose = false;
+    /** Presence. */
+    this._peers = /* @__PURE__ */ new Map();
+    this._localPresence = {};
+    this._presenceTimer = null;
+    this._presenceIntervalMs = 2e3;
+    this._peerTimeoutMs = 1e4;
+    /** Listeners. */
+    this._stateListeners = /* @__PURE__ */ new Set();
+    this._peerListeners = /* @__PURE__ */ new Set();
+    this._remoteChangeListeners = /* @__PURE__ */ new Set();
+  }
+  // ---- Public API ---------------------------------------------------------
+  get state() {
+    return this._state;
+  }
+  get peers() {
+    return this._peers;
+  }
+  /**
+   * Connect to the CRDT sync endpoint and start syncing a document.
+   *
+   * @param wsUrl - WebSocket URL, e.g. "wss://myapp.hanzo.ai/api/crdt"
+   * @param document - The CRDTDocument to sync.
+   * @param token - Optional auth token.
+   */
+  connect(wsUrl, document, token) {
+    if (this._ws) {
+      this.disconnect();
+    }
+    this._wsUrl = wsUrl;
+    this._document = document;
+    this._intentionalClose = false;
+    this._setState("connecting");
+    const url = new URL(wsUrl);
+    url.searchParams.set("documentId", document.id);
+    url.searchParams.set("siteId", document.clock.siteId);
+    if (token) {
+      url.searchParams.set("token", token);
+    }
+    this._ws = new WebSocket(url.toString());
+    this._ws.binaryType = "arraybuffer";
+    this._ws.onopen = () => {
+      this._reconnectAttempts = 0;
+      this._setState("connected");
+      if (document.getUnsyncedOps().length === 0) {
+        this._send({
+          type: "state_request",
+          documentId: document.id,
+          siteId: document.clock.siteId,
+          payload: {}
+        });
+      } else {
+        this._sendOps(Array.from(document.getUnsyncedOps()));
+      }
+      this._startFlush();
+      this._startPresence();
+    };
+    this._ws.onmessage = (e) => {
+      this._handleMessage(e.data);
+    };
+    this._ws.onclose = () => {
+      this._stopFlush();
+      this._stopPresence();
+      this._ws = null;
+      this._setState("disconnected");
+      if (!this._intentionalClose) {
+        this._scheduleReconnect();
+      }
+    };
+    this._ws.onerror = () => {
+    };
+  }
+  disconnect() {
+    this._intentionalClose = true;
+    this._stopFlush();
+    this._stopPresence();
+    this._clearReconnect();
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+    this._peers.clear();
+    this._setState("disconnected");
+  }
+  /** Update local presence metadata (cursor, name, etc.). */
+  updatePresence(meta) {
+    this._localPresence = meta;
+    this._broadcastPresence();
+  }
+  // ---- Listeners ----------------------------------------------------------
+  onStateChange(cb) {
+    this._stateListeners.add(cb);
+    return () => {
+      this._stateListeners.delete(cb);
+    };
+  }
+  onPeersChange(cb) {
+    this._peerListeners.add(cb);
+    return () => {
+      this._peerListeners.delete(cb);
+    };
+  }
+  onRemoteChange(cb) {
+    this._remoteChangeListeners.add(cb);
+    return () => {
+      this._remoteChangeListeners.delete(cb);
+    };
+  }
+  // ---- Message handling ---------------------------------------------------
+  _handleMessage(raw) {
+    let text;
+    if (raw instanceof ArrayBuffer) {
+      text = new TextDecoder().decode(raw);
+    } else {
+      text = raw;
+    }
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!this._document || msg.documentId !== this._document.id) return;
+    switch (msg.type) {
+      case "ops": {
+        const payload = msg.payload;
+        if (!payload.ops || payload.ops.length === 0) return;
+        const remoteOps = payload.ops.filter(
+          (op) => op.hlc.siteId !== this._document.clock.siteId
+        );
+        if (remoteOps.length > 0) {
+          this._document.applyRemoteOps(remoteOps);
+          for (const cb of this._remoteChangeListeners) {
+            try {
+              cb(remoteOps);
+            } catch {
+            }
+          }
+        }
+        break;
+      }
+      case "ack": {
+        const payload = msg.payload;
+        this._document.acknowledge(payload.lastOpId);
+        if (this._state === "syncing" && this._document.getUnsyncedOps().length === 0) {
+          this._setState("connected");
+        }
+        break;
+      }
+      case "presence": {
+        const payload = msg.payload;
+        if (msg.siteId === this._document.clock.siteId) return;
+        this._peers.set(msg.siteId, {
+          siteId: msg.siteId,
+          meta: payload.meta,
+          lastSeen: Date.now()
+        });
+        this._notifyPeers();
+        break;
+      }
+      case "state_response": {
+        const payload = msg.payload;
+        if (payload.ops && payload.ops.length > 0) {
+          this._document.applyRemoteOps(payload.ops);
+        }
+        break;
+      }
+    }
+  }
+  // ---- Flush (batched sending of local ops) -------------------------------
+  _startFlush() {
+    this._stopFlush();
+    this._flushTimer = setInterval(() => {
+      this._flush();
+    }, this._flushIntervalMs);
+  }
+  _stopFlush() {
+    if (this._flushTimer !== null) {
+      clearInterval(this._flushTimer);
+      this._flushTimer = null;
+    }
+  }
+  _flush() {
+    if (!this._document || !this._ws || this._ws.readyState !== WebSocket.OPEN) return;
+    const ops = this._document.collectOps();
+    if (ops.length === 0) return;
+    this._sendOps(ops);
+    this._setState("syncing");
+  }
+  _sendOps(ops) {
+    if (!this._document || !this._ws || this._ws.readyState !== WebSocket.OPEN) return;
+    this._send({
+      type: "ops",
+      documentId: this._document.id,
+      siteId: this._document.clock.siteId,
+      payload: { ops }
+    });
+  }
+  // ---- Presence -----------------------------------------------------------
+  _startPresence() {
+    this._stopPresence();
+    this._broadcastPresence();
+    this._presenceTimer = setInterval(() => {
+      this._broadcastPresence();
+      this._pruneStalePresence();
+    }, this._presenceIntervalMs);
+  }
+  _stopPresence() {
+    if (this._presenceTimer !== null) {
+      clearInterval(this._presenceTimer);
+      this._presenceTimer = null;
+    }
+  }
+  _broadcastPresence() {
+    if (!this._document || !this._ws || this._ws.readyState !== WebSocket.OPEN) return;
+    this._send({
+      type: "presence",
+      documentId: this._document.id,
+      siteId: this._document.clock.siteId,
+      payload: { meta: this._localPresence }
+    });
+  }
+  _pruneStalePresence() {
+    const now = Date.now();
+    let changed = false;
+    for (const [siteId, peer] of this._peers) {
+      if (now - peer.lastSeen > this._peerTimeoutMs) {
+        this._peers.delete(siteId);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this._notifyPeers();
+    }
+  }
+  // ---- Reconnection -------------------------------------------------------
+  _scheduleReconnect() {
+    this._clearReconnect();
+    const delay = Math.min(
+      this._baseReconnectDelay * Math.pow(2, this._reconnectAttempts),
+      this._maxReconnectDelay
+    );
+    const jitter = delay * (0.75 + Math.random() * 0.5);
+    this._reconnectAttempts++;
+    this._reconnectTimer = setTimeout(() => {
+      this._reconnectTimer = null;
+      if (this._document && this._wsUrl) {
+        this.connect(this._wsUrl, this._document);
+      }
+    }, jitter);
+  }
+  _clearReconnect() {
+    if (this._reconnectTimer !== null) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+  }
+  // ---- Internal helpers ---------------------------------------------------
+  _send(msg) {
+    if (!this._ws || this._ws.readyState !== WebSocket.OPEN) return;
+    this._ws.send(JSON.stringify(msg));
+  }
+  _setState(state) {
+    if (this._state === state) return;
+    this._state = state;
+    for (const cb of this._stateListeners) {
+      try {
+        cb(state);
+      } catch {
+      }
+    }
+  }
+  _notifyPeers() {
+    for (const cb of this._peerListeners) {
+      try {
+        cb(this._peers);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/crdt/clock.ts
+var HybridLogicalClock = class {
+  constructor(siteId) {
+    this.siteId = siteId ?? randomSiteId();
+    this._ts = Date.now();
+    this._counter = 0;
+  }
+  /** Generate a new timestamp, guaranteed > any previous. */
+  now() {
+    const wall = Date.now();
+    if (wall > this._ts) {
+      this._ts = wall;
+      this._counter = 0;
+    } else {
+      this._counter++;
+    }
+    return { ts: this._ts, counter: this._counter, siteId: this.siteId };
+  }
+  /** Receive a remote timestamp and merge with local clock. */
+  receive(remote) {
+    const wall = Date.now();
+    if (wall > this._ts && wall > remote.ts) {
+      this._ts = wall;
+      this._counter = 0;
+    } else if (remote.ts > this._ts) {
+      this._ts = remote.ts;
+      this._counter = remote.counter + 1;
+    } else if (this._ts > remote.ts) {
+      this._counter++;
+    } else {
+      this._counter = Math.max(this._counter, remote.counter) + 1;
+    }
+    return { ts: this._ts, counter: this._counter, siteId: this.siteId };
+  }
+};
+function compareHLC(a, b) {
+  if (a.ts !== b.ts) return a.ts - b.ts;
+  if (a.counter !== b.counter) return a.counter - b.counter;
+  if (a.siteId < b.siteId) return -1;
+  if (a.siteId > b.siteId) return 1;
+  return 0;
+}
+function randomSiteId() {
+  const buf = new Uint8Array(8);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(buf);
+  } else {
+    for (let i = 0; i < buf.length; i++) {
+      buf[i] = Math.random() * 256 | 0;
+    }
+  }
+  return Array.from(buf, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/crdt/operations.ts
+function makeOpId(hlc) {
+  return `${hlc.siteId}:${hlc.ts}:${hlc.counter}`;
+}
+function makePositionId(hlc, charIndex) {
+  return `${hlc.siteId}:${hlc.ts}:${hlc.counter}:${charIndex}`;
+}
+
+// src/crdt/text.ts
+var CRDTText = class {
+  constructor(documentId, field, clock) {
+    this._nodes = [];
+    this._pendingOps = [];
+    this._listeners = /* @__PURE__ */ new Set();
+    /** Index from position id to array index for O(1) lookup. */
+    this._index = /* @__PURE__ */ new Map();
+    this._documentId = documentId;
+    this._field = field;
+    this._clock = clock;
+  }
+  // ---- Public API ---------------------------------------------------------
+  /** Insert text at a visible character position (0-based). */
+  insert(position, text) {
+    if (text.length === 0) {
+      throw new Error("CRDTText.insert: empty text");
+    }
+    const afterId = this._visibleIdAtPosition(position - 1);
+    const hlc = this._clock.now();
+    const positionIds = [];
+    let prevId = afterId;
+    for (let i = 0; i < text.length; i++) {
+      const posId = makePositionId(hlc, i);
+      positionIds.push(posId);
+      const node = {
+        id: posId,
+        char: text[i],
+        hlc: { ...hlc, counter: hlc.counter + i },
+        tombstone: false,
+        afterId: prevId
+      };
+      this._insertNode(node);
+      prevId = posId;
+    }
+    const op = {
+      id: makeOpId(hlc),
+      documentId: this._documentId,
+      field: this._field,
+      hlc,
+      type: "text.insert",
+      payload: { afterId, content: text, positionIds }
+    };
+    this._pendingOps.push(op);
+    this._notifyChange();
+    return op;
+  }
+  /** Delete `length` visible characters starting at `position` (0-based). */
+  delete(position, length) {
+    const ids = this._visibleIdsInRange(position, length);
+    if (ids.length === 0) {
+      throw new Error("CRDTText.delete: nothing to delete");
+    }
+    for (const id of ids) {
+      const idx = this._index.get(id);
+      if (idx !== void 0) {
+        this._nodes[idx].tombstone = true;
+      }
+    }
+    const hlc = this._clock.now();
+    const op = {
+      id: makeOpId(hlc),
+      documentId: this._documentId,
+      field: this._field,
+      hlc,
+      type: "text.delete",
+      payload: { positionIds: ids }
+    };
+    this._pendingOps.push(op);
+    this._notifyChange();
+    return op;
+  }
+  /** Apply a remote operation. */
+  applyRemote(op) {
+    this._clock.receive(op.hlc);
+    if (op.type === "text.insert") {
+      const payload = op.payload;
+      for (let i = 0; i < payload.content.length; i++) {
+        const node = {
+          id: payload.positionIds[i],
+          char: payload.content[i],
+          hlc: { ...op.hlc, counter: op.hlc.counter + i },
+          tombstone: false,
+          afterId: i === 0 ? payload.afterId : payload.positionIds[i - 1]
+        };
+        this._insertNode(node);
+      }
+    } else if (op.type === "text.delete") {
+      const payload = op.payload;
+      for (const posId of payload.positionIds) {
+        const idx = this._index.get(posId);
+        if (idx !== void 0) {
+          this._nodes[idx].tombstone = true;
+        }
+      }
+    }
+    this._notifyChange();
+  }
+  /** Get the current visible text. */
+  toString() {
+    let result = "";
+    for (const node of this._nodes) {
+      if (!node.tombstone) {
+        result += node.char;
+      }
+    }
+    return result;
+  }
+  /** Number of visible characters. */
+  get length() {
+    let count = 0;
+    for (const node of this._nodes) {
+      if (!node.tombstone) count++;
+    }
+    return count;
+  }
+  /** Drain pending local operations. */
+  drainOps() {
+    return this._pendingOps.splice(0, this._pendingOps.length);
+  }
+  onChange(callback) {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  // ---- Internal -----------------------------------------------------------
+  /**
+   * Insert a node into the correct position in the array.
+   * RGA rule: among siblings sharing the same afterId, order by HLC descending
+   * (newer inserts appear first, pushing older ones right).
+   */
+  _insertNode(node) {
+    let parentIdx;
+    if (node.afterId === null) {
+      parentIdx = -1;
+    } else {
+      const idx = this._index.get(node.afterId);
+      if (idx === void 0) {
+        parentIdx = this._nodes.length - 1;
+      } else {
+        parentIdx = idx;
+      }
+    }
+    let insertIdx = parentIdx + 1;
+    while (insertIdx < this._nodes.length) {
+      const existing = this._nodes[insertIdx];
+      if (existing.afterId !== node.afterId) break;
+      if (compareHLC(existing.hlc, node.hlc) <= 0) break;
+      insertIdx++;
+    }
+    this._nodes.splice(insertIdx, 0, node);
+    this._rebuildIndex(insertIdx);
+  }
+  /** Rebuild the id->index map from `startIdx` onward. */
+  _rebuildIndex(startIdx) {
+    for (let i = startIdx; i < this._nodes.length; i++) {
+      this._index.set(this._nodes[i].id, i);
+    }
+  }
+  /** Get the position id of the visible character at position `pos`, or null for before-head. */
+  _visibleIdAtPosition(pos) {
+    if (pos < 0) return null;
+    let visible = -1;
+    for (const node of this._nodes) {
+      if (!node.tombstone) {
+        visible++;
+        if (visible === pos) return node.id;
+      }
+    }
+    for (let i = this._nodes.length - 1; i >= 0; i--) {
+      if (!this._nodes[i].tombstone) return this._nodes[i].id;
+    }
+    return null;
+  }
+  /** Get position ids for `length` visible characters starting at `position`. */
+  _visibleIdsInRange(position, length) {
+    const ids = [];
+    let visible = -1;
+    for (const node of this._nodes) {
+      if (node.tombstone) continue;
+      visible++;
+      if (visible >= position && visible < position + length) {
+        ids.push(node.id);
+      }
+      if (ids.length === length) break;
+    }
+    return ids;
+  }
+  _notifyChange() {
+    if (this._listeners.size === 0) return;
+    const text = this.toString();
+    for (const cb of this._listeners) {
+      try {
+        cb(text);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/crdt/counter.ts
+var CRDTCounter = class {
+  constructor(documentId, field, clock) {
+    /** Per-site positive accumulator. */
+    this._positive = /* @__PURE__ */ new Map();
+    /** Per-site negative accumulator. */
+    this._negative = /* @__PURE__ */ new Map();
+    this._pendingOps = [];
+    this._listeners = /* @__PURE__ */ new Set();
+    this._documentId = documentId;
+    this._field = field;
+    this._clock = clock;
+  }
+  // ---- Public API ---------------------------------------------------------
+  get value() {
+    let pos = 0;
+    let neg = 0;
+    for (const v of this._positive.values()) pos += v;
+    for (const v of this._negative.values()) neg += v;
+    return pos - neg;
+  }
+  increment(amount = 1) {
+    if (amount === 0) throw new Error("CRDTCounter: amount must be nonzero");
+    const siteId = this._clock.siteId;
+    if (amount > 0) {
+      this._positive.set(siteId, (this._positive.get(siteId) ?? 0) + amount);
+    } else {
+      this._negative.set(siteId, (this._negative.get(siteId) ?? 0) + Math.abs(amount));
+    }
+    const hlc = this._clock.now();
+    const op = {
+      id: makeOpId(hlc),
+      documentId: this._documentId,
+      field: this._field,
+      hlc,
+      type: "counter.increment",
+      payload: { delta: amount }
+    };
+    this._pendingOps.push(op);
+    this._notifyChange();
+    return op;
+  }
+  decrement(amount = 1) {
+    return this.increment(-amount);
+  }
+  /** Apply a remote increment operation. */
+  applyRemote(op) {
+    if (op.type !== "counter.increment") return;
+    this._clock.receive(op.hlc);
+    const payload = op.payload;
+    const siteId = op.hlc.siteId;
+    if (payload.delta > 0) {
+      this._positive.set(siteId, (this._positive.get(siteId) ?? 0) + payload.delta);
+    } else {
+      this._negative.set(siteId, (this._negative.get(siteId) ?? 0) + Math.abs(payload.delta));
+    }
+    this._notifyChange();
+  }
+  /** Merge with a remote counter state (for full-state sync). */
+  mergeState(positives, negatives) {
+    for (const [site, val] of Object.entries(positives)) {
+      this._positive.set(site, Math.max(this._positive.get(site) ?? 0, val));
+    }
+    for (const [site, val] of Object.entries(negatives)) {
+      this._negative.set(site, Math.max(this._negative.get(site) ?? 0, val));
+    }
+    this._notifyChange();
+  }
+  /** Export state for full-state sync. */
+  exportState() {
+    return {
+      positive: Object.fromEntries(this._positive),
+      negative: Object.fromEntries(this._negative)
+    };
+  }
+  drainOps() {
+    return this._pendingOps.splice(0, this._pendingOps.length);
+  }
+  onChange(callback) {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  _notifyChange() {
+    if (this._listeners.size === 0) return;
+    const val = this.value;
+    for (const cb of this._listeners) {
+      try {
+        cb(val);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/crdt/set.ts
+var CRDTSet = class {
+  constructor(documentId, field, clock) {
+    /** Map from serialized value key to tagged entry. */
+    this._entries = /* @__PURE__ */ new Map();
+    this._pendingOps = [];
+    this._listeners = /* @__PURE__ */ new Set();
+    this._documentId = documentId;
+    this._field = field;
+    this._clock = clock;
+  }
+  // ---- Public API ---------------------------------------------------------
+  get values() {
+    const result = [];
+    for (const entry of this._entries.values()) {
+      if (entry.tags.size > 0) {
+        result.push(entry.value);
+      }
+    }
+    return result;
+  }
+  get size() {
+    let count = 0;
+    for (const entry of this._entries.values()) {
+      if (entry.tags.size > 0) count++;
+    }
+    return count;
+  }
+  has(item) {
+    const key = this._keyOf(item);
+    const entry = this._entries.get(key);
+    return entry !== void 0 && entry.tags.size > 0;
+  }
+  add(item) {
+    const hlc = this._clock.now();
+    const tag = makeOpId(hlc);
+    const key = this._keyOf(item);
+    let entry = this._entries.get(key);
+    if (!entry) {
+      entry = { value: item, tags: /* @__PURE__ */ new Set() };
+      this._entries.set(key, entry);
+    }
+    entry.tags.add(tag);
+    const op = {
+      id: tag,
+      documentId: this._documentId,
+      field: this._field,
+      hlc,
+      type: "set.add",
+      payload: { value: item, tag }
+    };
+    this._pendingOps.push(op);
+    this._notifyChange();
+    return op;
+  }
+  remove(item) {
+    const key = this._keyOf(item);
+    const entry = this._entries.get(key);
+    const observedTags = entry ? Array.from(entry.tags) : [];
+    if (entry) {
+      entry.tags.clear();
+    }
+    const hlc = this._clock.now();
+    const op = {
+      id: makeOpId(hlc),
+      documentId: this._documentId,
+      field: this._field,
+      hlc,
+      type: "set.remove",
+      payload: { value: item, tags: observedTags }
+    };
+    this._pendingOps.push(op);
+    this._notifyChange();
+    return op;
+  }
+  /** Apply a remote operation. */
+  applyRemote(op) {
+    this._clock.receive(op.hlc);
+    if (op.type === "set.add") {
+      const payload = op.payload;
+      const key = this._keyOf(payload.value);
+      let entry = this._entries.get(key);
+      if (!entry) {
+        entry = { value: payload.value, tags: /* @__PURE__ */ new Set() };
+        this._entries.set(key, entry);
+      }
+      entry.tags.add(payload.tag);
+    } else if (op.type === "set.remove") {
+      const payload = op.payload;
+      const key = this._keyOf(payload.value);
+      const entry = this._entries.get(key);
+      if (entry) {
+        for (const tag of payload.tags) {
+          entry.tags.delete(tag);
+        }
+      }
+    }
+    this._notifyChange();
+  }
+  drainOps() {
+    return this._pendingOps.splice(0, this._pendingOps.length);
+  }
+  onChange(callback) {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  // ---- Internal -----------------------------------------------------------
+  _keyOf(value) {
+    return JSON.stringify(value);
+  }
+  _notifyChange() {
+    if (this._listeners.size === 0) return;
+    const vals = this.values;
+    for (const cb of this._listeners) {
+      try {
+        cb(vals);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/crdt/register.ts
+var CRDTRegister = class {
+  constructor(documentId, field, clock) {
+    this._value = void 0;
+    this._hlc = null;
+    this._pendingOps = [];
+    this._listeners = /* @__PURE__ */ new Set();
+    this._documentId = documentId;
+    this._field = field;
+    this._clock = clock;
+  }
+  // ---- Public API ---------------------------------------------------------
+  get value() {
+    return this._value;
+  }
+  set(value) {
+    const hlc = this._clock.now();
+    this._value = value;
+    this._hlc = hlc;
+    const op = {
+      id: makeOpId(hlc),
+      documentId: this._documentId,
+      field: this._field,
+      hlc,
+      type: "register.set",
+      payload: { value }
+    };
+    this._pendingOps.push(op);
+    this._notifyChange();
+    return op;
+  }
+  /** Apply a remote set operation. LWW: only apply if remote HLC > current. */
+  applyRemote(op) {
+    if (op.type !== "register.set") return;
+    this._clock.receive(op.hlc);
+    const payload = op.payload;
+    if (this._hlc === null || compareHLC(op.hlc, this._hlc) > 0) {
+      this._value = payload.value;
+      this._hlc = op.hlc;
+      this._notifyChange();
+    }
+  }
+  /** Export current state for full-state sync. */
+  exportState() {
+    return { value: this._value, hlc: this._hlc };
+  }
+  /** Import state from full-state sync. LWW merge. */
+  importState(value, hlc) {
+    if (this._hlc === null || compareHLC(hlc, this._hlc) > 0) {
+      this._value = value;
+      this._hlc = hlc;
+      this._notifyChange();
+    }
+  }
+  drainOps() {
+    return this._pendingOps.splice(0, this._pendingOps.length);
+  }
+  onChange(callback) {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  _notifyChange() {
+    if (this._listeners.size === 0) return;
+    const val = this._value;
+    for (const cb of this._listeners) {
+      try {
+        cb(val);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/crdt/document.ts
+var CRDTDocument = class {
+  constructor(id, siteId) {
+    this._texts = /* @__PURE__ */ new Map();
+    this._counters = /* @__PURE__ */ new Map();
+    this._sets = /* @__PURE__ */ new Map();
+    this._registers = /* @__PURE__ */ new Map();
+    this._listeners = /* @__PURE__ */ new Set();
+    /** Buffer for ops not yet synced. */
+    this._unsyncedOps = [];
+    this.id = id;
+    this.clock = new HybridLogicalClock(siteId);
+  }
+  // ---- Field accessors ----------------------------------------------------
+  getText(field) {
+    let t = this._texts.get(field);
+    if (!t) {
+      t = new CRDTText(this.id, field, this.clock);
+      this._texts.set(field, t);
+    }
+    return t;
+  }
+  getCounter(field) {
+    let c = this._counters.get(field);
+    if (!c) {
+      c = new CRDTCounter(this.id, field, this.clock);
+      this._counters.set(field, c);
+    }
+    return c;
+  }
+  getSet(field) {
+    let s = this._sets.get(field);
+    if (!s) {
+      s = new CRDTSet(this.id, field, this.clock);
+      this._sets.set(field, s);
+    }
+    return s;
+  }
+  getRegister(field) {
+    let r = this._registers.get(field);
+    if (!r) {
+      r = new CRDTRegister(this.id, field, this.clock);
+      this._registers.set(field, r);
+    }
+    return r;
+  }
+  // ---- Operation collection -----------------------------------------------
+  /**
+   * Collect all pending local operations from all fields.
+   * Drains the per-field op buffers and returns them.
+   */
+  collectOps() {
+    const ops = [];
+    for (const t of this._texts.values()) ops.push(...t.drainOps());
+    for (const c of this._counters.values()) ops.push(...c.drainOps());
+    for (const s of this._sets.values()) ops.push(...s.drainOps());
+    for (const r of this._registers.values()) ops.push(...r.drainOps());
+    this._unsyncedOps.push(...ops);
+    return ops;
+  }
+  /**
+   * Acknowledge that operations up to and including `opId` have been
+   * persisted by the server. Removes them from the unsynced buffer.
+   */
+  acknowledge(opId) {
+    const idx = this._unsyncedOps.findIndex((op) => op.id === opId);
+    if (idx >= 0) {
+      this._unsyncedOps.splice(0, idx + 1);
+    }
+  }
+  /** Get operations that have not been acknowledged by the server. */
+  getUnsyncedOps() {
+    return this._unsyncedOps;
+  }
+  // ---- Remote operation application ---------------------------------------
+  /**
+   * Apply a batch of remote operations to the appropriate CRDT fields.
+   */
+  applyRemoteOps(ops) {
+    for (const op of ops) {
+      if (op.documentId !== this.id) continue;
+      this._applyRemoteOp(op);
+    }
+  }
+  _applyRemoteOp(op) {
+    switch (op.type) {
+      case "text.insert":
+      case "text.delete": {
+        const t = this.getText(op.field);
+        t.applyRemote(op);
+        break;
+      }
+      case "counter.increment": {
+        const c = this.getCounter(op.field);
+        c.applyRemote(op);
+        break;
+      }
+      case "set.add":
+      case "set.remove": {
+        const s = this.getSet(op.field);
+        s.applyRemote(op);
+        break;
+      }
+      case "register.set": {
+        const r = this.getRegister(op.field);
+        r.applyRemote(op);
+        break;
+      }
+    }
+  }
+  // ---- Serialization ------------------------------------------------------
+  /**
+   * Encode all pending operations as a Uint8Array (JSON wire format).
+   * Used for WebSocket transmission.
+   */
+  encode() {
+    const ops = this.collectOps();
+    const json = JSON.stringify({
+      documentId: this.id,
+      siteId: this.clock.siteId,
+      ops
+    });
+    return new TextEncoder().encode(json);
+  }
+  /**
+   * Decode and apply a remote message (Uint8Array or string).
+   */
+  decode(data) {
+    const text = typeof data === "string" ? data : new TextDecoder().decode(data);
+    const msg = JSON.parse(text);
+    if (msg.documentId !== this.id) return;
+    if (msg.siteId === this.clock.siteId) return;
+    this.applyRemoteOps(msg.ops);
+    this._notifyChange(msg.ops);
+  }
+  // ---- Change notifications -----------------------------------------------
+  onChange(callback) {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  _notifyChange(ops) {
+    for (const cb of this._listeners) {
+      try {
+        cb(ops);
+      } catch {
+      }
+    }
+  }
+};
+
+export { CRDTCounter, CRDTDocument, CRDTRegister, CRDTSet, CRDTSync, CRDTText, HybridLogicalClock, compareHLC, makeOpId, makePositionId };
+//# sourceMappingURL=chunk-5NHFZRMO.js.map
+//# sourceMappingURL=chunk-5NHFZRMO.js.map