@korajs/sync 0.1.0

package/dist/index.js

@@ -0,0 +1,1659 @@
+import {
+  MemoryQueueStorage
+} from "./chunk-TU345YUC.js";
+
+// src/types.ts
+var SYNC_STATES = [
+  "disconnected",
+  "connecting",
+  "handshaking",
+  "syncing",
+  "streaming",
+  "error"
+];
+var SYNC_STATUSES = ["connected", "syncing", "synced", "offline", "error"];
+
+// src/protocol/messages.ts
+function isSyncMessage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const msg = value;
+  if (typeof msg.type !== "string" || typeof msg.messageId !== "string") return false;
+  switch (msg.type) {
+    case "handshake":
+      return isHandshakeMessage(value);
+    case "handshake-response":
+      return isHandshakeResponseMessage(value);
+    case "operation-batch":
+      return isOperationBatchMessage(value);
+    case "acknowledgment":
+      return isAcknowledgmentMessage(value);
+    case "error":
+      return isErrorMessage(value);
+    default:
+      return false;
+  }
+}
+function isHandshakeMessage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const msg = value;
+  return msg.type === "handshake" && typeof msg.messageId === "string" && typeof msg.nodeId === "string" && typeof msg.versionVector === "object" && msg.versionVector !== null && !Array.isArray(msg.versionVector) && typeof msg.schemaVersion === "number";
+}
+function isHandshakeResponseMessage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const msg = value;
+  return msg.type === "handshake-response" && typeof msg.messageId === "string" && typeof msg.nodeId === "string" && typeof msg.versionVector === "object" && msg.versionVector !== null && !Array.isArray(msg.versionVector) && typeof msg.schemaVersion === "number" && typeof msg.accepted === "boolean";
+}
+function isOperationBatchMessage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const msg = value;
+  return msg.type === "operation-batch" && typeof msg.messageId === "string" && Array.isArray(msg.operations) && typeof msg.isFinal === "boolean" && typeof msg.batchIndex === "number";
+}
+function isAcknowledgmentMessage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const msg = value;
+  return msg.type === "acknowledgment" && typeof msg.messageId === "string" && typeof msg.acknowledgedMessageId === "string" && typeof msg.lastSequenceNumber === "number";
+}
+function isErrorMessage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const msg = value;
+  return msg.type === "error" && typeof msg.messageId === "string" && typeof msg.code === "string" && typeof msg.message === "string" && typeof msg.retriable === "boolean";
+}
+
+// src/protocol/serializer.ts
+import { SyncError } from "@korajs/core";
+import { Reader, Writer } from "protobufjs/minimal";
+function versionVectorToWire(vector) {
+  const wire = {};
+  for (const [nodeId, seq] of vector) {
+    wire[nodeId] = seq;
+  }
+  return wire;
+}
+function wireToVersionVector(wire) {
+  return new Map(Object.entries(wire));
+}
+var JsonMessageSerializer = class {
+  encode(message) {
+    return JSON.stringify(message);
+  }
+  decode(data) {
+    const text = decodeTextPayload(data);
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new SyncError("Failed to decode sync message: invalid JSON", {
+        dataLength: text.length
+      });
+    }
+    if (!isSyncMessage(parsed)) {
+      throw new SyncError("Failed to decode sync message: invalid message structure", {
+        receivedType: typeof parsed === "object" && parsed !== null ? parsed.type : typeof parsed
+      });
+    }
+    return parsed;
+  }
+  encodeOperation(op) {
+    return {
+      id: op.id,
+      nodeId: op.nodeId,
+      type: op.type,
+      collection: op.collection,
+      recordId: op.recordId,
+      data: op.data,
+      previousData: op.previousData,
+      timestamp: {
+        wallTime: op.timestamp.wallTime,
+        logical: op.timestamp.logical,
+        nodeId: op.timestamp.nodeId
+      },
+      sequenceNumber: op.sequenceNumber,
+      causalDeps: [...op.causalDeps],
+      schemaVersion: op.schemaVersion
+    };
+  }
+  decodeOperation(serialized) {
+    return {
+      id: serialized.id,
+      nodeId: serialized.nodeId,
+      type: serialized.type,
+      collection: serialized.collection,
+      recordId: serialized.recordId,
+      data: serialized.data,
+      previousData: serialized.previousData,
+      timestamp: {
+        wallTime: serialized.timestamp.wallTime,
+        logical: serialized.timestamp.logical,
+        nodeId: serialized.timestamp.nodeId
+      },
+      sequenceNumber: serialized.sequenceNumber,
+      causalDeps: [...serialized.causalDeps],
+      schemaVersion: serialized.schemaVersion
+    };
+  }
+};
+var ProtobufMessageSerializer = class {
+  encode(message) {
+    const envelope = toProtoEnvelope(message);
+    return encodeEnvelope(envelope);
+  }
+  decode(data) {
+    const bytes = toBytes(data);
+    const envelope = decodeEnvelope(bytes);
+    return fromProtoEnvelope(envelope);
+  }
+  encodeOperation(op) {
+    return new JsonMessageSerializer().encodeOperation(op);
+  }
+  decodeOperation(serialized) {
+    return new JsonMessageSerializer().decodeOperation(serialized);
+  }
+};
+var NegotiatedMessageSerializer = class {
+  json = new JsonMessageSerializer();
+  protobuf = new ProtobufMessageSerializer();
+  wireFormat;
+  constructor(initialWireFormat = "json") {
+    this.wireFormat = initialWireFormat;
+  }
+  encode(message) {
+    if (this.wireFormat === "protobuf") {
+      return this.protobuf.encode(message);
+    }
+    return this.json.encode(message);
+  }
+  decode(data) {
+    if (typeof data === "string") {
+      return this.json.decode(data);
+    }
+    try {
+      return this.protobuf.decode(data);
+    } catch {
+      return this.json.decode(data);
+    }
+  }
+  encodeOperation(op) {
+    return this.json.encodeOperation(op);
+  }
+  decodeOperation(serialized) {
+    return this.json.decodeOperation(serialized);
+  }
+  setWireFormat(format) {
+    this.wireFormat = format;
+  }
+  getWireFormat() {
+    return this.wireFormat;
+  }
+};
+function toProtoEnvelope(message) {
+  switch (message.type) {
+    case "handshake":
+      return {
+        type: message.type,
+        messageId: message.messageId,
+        nodeId: message.nodeId,
+        versionVector: Object.entries(message.versionVector).map(([key, value]) => ({ key, value })),
+        schemaVersion: message.schemaVersion,
+        authToken: message.authToken,
+        supportedWireFormats: message.supportedWireFormats
+      };
+    case "handshake-response":
+      return {
+        type: message.type,
+        messageId: message.messageId,
+        nodeId: message.nodeId,
+        versionVector: Object.entries(message.versionVector).map(([key, value]) => ({ key, value })),
+        schemaVersion: message.schemaVersion,
+        accepted: message.accepted,
+        rejectReason: message.rejectReason,
+        selectedWireFormat: message.selectedWireFormat
+      };
+    case "operation-batch":
+      return {
+        type: message.type,
+        messageId: message.messageId,
+        operations: message.operations.map(serializeProtoOperation),
+        isFinal: message.isFinal,
+        batchIndex: message.batchIndex
+      };
+    case "acknowledgment":
+      return {
+        type: message.type,
+        messageId: message.messageId,
+        acknowledgedMessageId: message.acknowledgedMessageId,
+        lastSequenceNumber: message.lastSequenceNumber
+      };
+    case "error":
+      return {
+        type: message.type,
+        messageId: message.messageId,
+        errorCode: message.code,
+        errorMessage: message.message,
+        retriable: message.retriable
+      };
+  }
+}
+function fromProtoEnvelope(envelope) {
+  switch (envelope.type) {
+    case "handshake":
+      return {
+        type: "handshake",
+        messageId: envelope.messageId,
+        nodeId: envelope.nodeId ?? "",
+        versionVector: Object.fromEntries((envelope.versionVector ?? []).map((entry) => [entry.key, entry.value])),
+        schemaVersion: envelope.schemaVersion ?? 0,
+        authToken: envelope.authToken,
+        supportedWireFormats: envelope.supportedWireFormats?.filter(
+          (format) => format === "json" || format === "protobuf"
+        )
+      };
+    case "handshake-response":
+      return {
+        type: "handshake-response",
+        messageId: envelope.messageId,
+        nodeId: envelope.nodeId ?? "",
+        versionVector: Object.fromEntries((envelope.versionVector ?? []).map((entry) => [entry.key, entry.value])),
+        schemaVersion: envelope.schemaVersion ?? 0,
+        accepted: envelope.accepted ?? false,
+        rejectReason: envelope.rejectReason,
+        selectedWireFormat: envelope.selectedWireFormat === "json" || envelope.selectedWireFormat === "protobuf" ? envelope.selectedWireFormat : void 0
+      };
+    case "operation-batch":
+      return {
+        type: "operation-batch",
+        messageId: envelope.messageId,
+        operations: (envelope.operations ?? []).map(deserializeProtoOperation),
+        isFinal: envelope.isFinal ?? false,
+        batchIndex: envelope.batchIndex ?? 0
+      };
+    case "acknowledgment":
+      return {
+        type: "acknowledgment",
+        messageId: envelope.messageId,
+        acknowledgedMessageId: envelope.acknowledgedMessageId ?? "",
+        lastSequenceNumber: envelope.lastSequenceNumber ?? 0
+      };
+    case "error":
+      return {
+        type: "error",
+        messageId: envelope.messageId,
+        code: envelope.errorCode ?? "UNKNOWN",
+        message: envelope.errorMessage ?? "Unknown error",
+        retriable: envelope.retriable ?? false
+      };
+    default:
+      throw new SyncError("Failed to decode sync message: unknown protobuf type", {
+        type: envelope.type
+      });
+  }
+}
+function serializeProtoOperation(operation) {
+  return {
+    id: operation.id,
+    nodeId: operation.nodeId,
+    type: operation.type,
+    collection: operation.collection,
+    recordId: operation.recordId,
+    dataJson: operation.data === null ? "" : JSON.stringify(operation.data),
+    previousDataJson: operation.previousData === null ? "" : JSON.stringify(operation.previousData),
+    timestamp: {
+      wallTime: operation.timestamp.wallTime,
+      logical: operation.timestamp.logical,
+      nodeId: operation.timestamp.nodeId
+    },
+    sequenceNumber: operation.sequenceNumber,
+    causalDeps: [...operation.causalDeps],
+    schemaVersion: operation.schemaVersion,
+    hasData: operation.data !== null,
+    hasPreviousData: operation.previousData !== null
+  };
+}
+function deserializeProtoOperation(operation) {
+  return {
+    id: operation.id,
+    nodeId: operation.nodeId,
+    type: operation.type,
+    collection: operation.collection,
+    recordId: operation.recordId,
+    data: operation.hasData ? JSON.parse(operation.dataJson) : null,
+    previousData: operation.hasPreviousData ? JSON.parse(operation.previousDataJson) : null,
+    timestamp: {
+      wallTime: operation.timestamp.wallTime,
+      logical: operation.timestamp.logical,
+      nodeId: operation.timestamp.nodeId
+    },
+    sequenceNumber: operation.sequenceNumber,
+    causalDeps: [...operation.causalDeps],
+    schemaVersion: operation.schemaVersion
+  };
+}
+function decodeTextPayload(data) {
+  if (typeof data === "string") return data;
+  return new TextDecoder().decode(toBytes(data));
+}
+function toBytes(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  throw new SyncError("Unsupported sync payload type", { receivedType: typeof data });
+}
+function encodeEnvelope(envelope) {
+  const writer = Writer.create();
+  if (envelope.type.length > 0) writer.uint32(10).string(envelope.type);
+  if (envelope.messageId.length > 0) writer.uint32(18).string(envelope.messageId);
+  if (envelope.nodeId && envelope.nodeId.length > 0) writer.uint32(26).string(envelope.nodeId);
+  for (const entry of envelope.versionVector ?? []) {
+    writer.uint32(34).fork();
+    writer.uint32(10).string(entry.key);
+    writer.uint32(16).int64(entry.value);
+    writer.ldelim();
+  }
+  if (envelope.schemaVersion !== void 0) writer.uint32(40).int32(envelope.schemaVersion);
+  if (envelope.authToken && envelope.authToken.length > 0) writer.uint32(50).string(envelope.authToken);
+  for (const format of envelope.supportedWireFormats ?? []) {
+    writer.uint32(58).string(format);
+  }
+  if (envelope.accepted !== void 0) writer.uint32(64).bool(envelope.accepted);
+  if (envelope.rejectReason && envelope.rejectReason.length > 0) writer.uint32(74).string(envelope.rejectReason);
+  if (envelope.selectedWireFormat && envelope.selectedWireFormat.length > 0) {
+    writer.uint32(82).string(envelope.selectedWireFormat);
+  }
+  for (const operation of envelope.operations ?? []) {
+    writer.uint32(90).fork();
+    encodeProtoOperation(writer, operation);
+    writer.ldelim();
+  }
+  if (envelope.isFinal !== void 0) writer.uint32(96).bool(envelope.isFinal);
+  if (envelope.batchIndex !== void 0) writer.uint32(104).uint32(envelope.batchIndex);
+  if (envelope.acknowledgedMessageId && envelope.acknowledgedMessageId.length > 0) {
+    writer.uint32(114).string(envelope.acknowledgedMessageId);
+  }
+  if (envelope.lastSequenceNumber !== void 0) writer.uint32(120).int64(envelope.lastSequenceNumber);
+  if (envelope.errorCode && envelope.errorCode.length > 0) writer.uint32(130).string(envelope.errorCode);
+  if (envelope.errorMessage && envelope.errorMessage.length > 0) {
+    writer.uint32(138).string(envelope.errorMessage);
+  }
+  if (envelope.retriable !== void 0) writer.uint32(144).bool(envelope.retriable);
+  return writer.finish();
+}
+function decodeEnvelope(bytes) {
+  const reader = Reader.create(bytes);
+  const envelope = { type: "error", messageId: "" };
+  while (reader.pos < reader.len) {
+    const tag = reader.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        envelope.type = reader.string();
+        break;
+      case 2:
+        envelope.messageId = reader.string();
+        break;
+      case 3:
+        envelope.nodeId = reader.string();
+        break;
+      case 4:
+        envelope.versionVector = [...envelope.versionVector ?? [], decodeVectorEntry(reader, reader.uint32())];
+        break;
+      case 5:
+        envelope.schemaVersion = reader.int32();
+        break;
+      case 6:
+        envelope.authToken = reader.string();
+        break;
+      case 7:
+        envelope.supportedWireFormats = [...envelope.supportedWireFormats ?? [], reader.string()];
+        break;
+      case 8:
+        envelope.accepted = reader.bool();
+        break;
+      case 9:
+        envelope.rejectReason = reader.string();
+        break;
+      case 10:
+        envelope.selectedWireFormat = reader.string();
+        break;
+      case 11:
+        envelope.operations = [...envelope.operations ?? [], decodeProtoOperation(reader, reader.uint32())];
+        break;
+      case 12:
+        envelope.isFinal = reader.bool();
+        break;
+      case 13:
+        envelope.batchIndex = reader.uint32();
+        break;
+      case 14:
+        envelope.acknowledgedMessageId = reader.string();
+        break;
+      case 15:
+        envelope.lastSequenceNumber = longToNumber(reader.int64());
+        break;
+      case 16:
+        envelope.errorCode = reader.string();
+        break;
+      case 17:
+        envelope.errorMessage = reader.string();
+        break;
+      case 18:
+        envelope.retriable = reader.bool();
+        break;
+      default:
+        reader.skipType(tag & 7);
+    }
+  }
+  return envelope;
+}
+function encodeProtoOperation(writer, operation) {
+  if (operation.id.length > 0) writer.uint32(10).string(operation.id);
+  if (operation.nodeId.length > 0) writer.uint32(18).string(operation.nodeId);
+  if (operation.type.length > 0) writer.uint32(26).string(operation.type);
+  if (operation.collection.length > 0) writer.uint32(34).string(operation.collection);
+  if (operation.recordId.length > 0) writer.uint32(42).string(operation.recordId);
+  if (operation.dataJson.length > 0) writer.uint32(50).string(operation.dataJson);
+  if (operation.previousDataJson.length > 0) writer.uint32(58).string(operation.previousDataJson);
+  writer.uint32(66).fork();
+  writer.uint32(8).int64(operation.timestamp.wallTime);
+  writer.uint32(16).uint32(operation.timestamp.logical);
+  writer.uint32(26).string(operation.timestamp.nodeId);
+  writer.ldelim();
+  writer.uint32(72).int64(operation.sequenceNumber);
+  for (const dep of operation.causalDeps) {
+    writer.uint32(82).string(dep);
+  }
+  writer.uint32(88).int32(operation.schemaVersion);
+  writer.uint32(96).bool(operation.hasData);
+  writer.uint32(104).bool(operation.hasPreviousData);
+}
+function decodeProtoOperation(reader, length) {
+  const end = reader.pos + length;
+  const operation = {
+    id: "",
+    nodeId: "",
+    type: "insert",
+    collection: "",
+    recordId: "",
+    dataJson: "",
+    previousDataJson: "",
+    timestamp: { wallTime: 0, logical: 0, nodeId: "" },
+    sequenceNumber: 0,
+    causalDeps: [],
+    schemaVersion: 0,
+    hasData: false,
+    hasPreviousData: false
+  };
+  while (reader.pos < end) {
+    const tag = reader.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        operation.id = reader.string();
+        break;
+      case 2:
+        operation.nodeId = reader.string();
+        break;
+      case 3:
+        operation.type = reader.string();
+        break;
+      case 4:
+        operation.collection = reader.string();
+        break;
+      case 5:
+        operation.recordId = reader.string();
+        break;
+      case 6:
+        operation.dataJson = reader.string();
+        break;
+      case 7:
+        operation.previousDataJson = reader.string();
+        break;
+      case 8: {
+        const timestampEnd = reader.pos + reader.uint32();
+        while (reader.pos < timestampEnd) {
+          const timestampTag = reader.uint32();
+          switch (timestampTag >>> 3) {
+            case 1:
+              operation.timestamp.wallTime = longToNumber(reader.int64());
+              break;
+            case 2:
+              operation.timestamp.logical = reader.uint32();
+              break;
+            case 3:
+              operation.timestamp.nodeId = reader.string();
+              break;
+            default:
+              reader.skipType(timestampTag & 7);
+          }
+        }
+        break;
+      }
+      case 9:
+        operation.sequenceNumber = longToNumber(reader.int64());
+        break;
+      case 10:
+        operation.causalDeps.push(reader.string());
+        break;
+      case 11:
+        operation.schemaVersion = reader.int32();
+        break;
+      case 12:
+        operation.hasData = reader.bool();
+        break;
+      case 13:
+        operation.hasPreviousData = reader.bool();
+        break;
+      default:
+        reader.skipType(tag & 7);
+    }
+  }
+  return operation;
+}
+function decodeVectorEntry(reader, length) {
+  const end = reader.pos + length;
+  const entry = { key: "", value: 0 };
+  while (reader.pos < end) {
+    const tag = reader.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        entry.key = reader.string();
+        break;
+      case 2:
+        entry.value = longToNumber(reader.int64());
+        break;
+      default:
+        reader.skipType(tag & 7);
+    }
+  }
+  return entry;
+}
+function longToNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return Number.parseInt(value, 10);
+  if (typeof value === "object" && value !== null && "toNumber" in value && typeof value.toNumber === "function") {
+    return value.toNumber();
+  }
+  throw new SyncError("Failed to decode int64 value", {
+    receivedType: typeof value
+  });
+}
+
+// src/transport/websocket-transport.ts
+import { SyncError as SyncError2 } from "@korajs/core";
+var WS_OPEN = 1;
+var WebSocketTransport = class {
+  ws = null;
+  messageHandler = null;
+  closeHandler = null;
+  errorHandler = null;
+  serializer;
+  WebSocketImpl;
+  constructor(options) {
+    this.serializer = options?.serializer ?? new JsonMessageSerializer();
+    if (options?.WebSocketImpl) {
+      this.WebSocketImpl = options.WebSocketImpl;
+    } else if (typeof globalThis.WebSocket !== "undefined") {
+      this.WebSocketImpl = globalThis.WebSocket;
+    } else {
+      this.WebSocketImpl = null;
+    }
+  }
+  async connect(url, options) {
+    if (!this.WebSocketImpl) {
+      throw new SyncError2("WebSocket is not available in this environment", {
+        hint: "Provide a WebSocketImpl option or use a polyfill"
+      });
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        const connectUrl = options?.authToken ? `${url}${url.includes("?") ? "&" : "?"}token=${encodeURIComponent(options.authToken)}` : url;
+        const ws = new this.WebSocketImpl(connectUrl);
+        this.ws = ws;
+        ws.onopen = () => {
+          resolve();
+        };
+        ws.onmessage = (event) => {
+          try {
+            if (typeof event.data !== "string" && !(event.data instanceof Uint8Array) && !(event.data instanceof ArrayBuffer)) {
+              return;
+            }
+            const message = this.serializer.decode(event.data);
+            this.messageHandler?.(message);
+          } catch {
+            this.errorHandler?.(new SyncError2("Failed to decode incoming message"));
+          }
+        };
+        ws.onclose = (event) => {
+          this.ws = null;
+          this.closeHandler?.(event.reason || `WebSocket closed with code ${event.code}`);
+        };
+        ws.onerror = (event) => {
+          const err = new SyncError2("WebSocket error", {
+            url
+          });
+          this.errorHandler?.(err);
+          if (!this.isConnected()) {
+            this.ws = null;
+            reject(err);
+          }
+        };
+      } catch (err) {
+        reject(
+          err instanceof SyncError2 ? err : new SyncError2("Failed to create WebSocket", {
+            url,
+            error: String(err)
+          })
+        );
+      }
+    });
+  }
+  async disconnect() {
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close(1e3, "Client disconnecting");
+      this.ws = null;
+    }
+  }
+  send(message) {
+    if (!this.ws || this.ws.readyState !== WS_OPEN) {
+      throw new SyncError2("Cannot send message: WebSocket is not connected", {
+        messageType: message.type
+      });
+    }
+    const encoded = this.serializer.encode(message);
+    this.ws.send(encoded);
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onClose(handler) {
+    this.closeHandler = handler;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === WS_OPEN;
+  }
+};
+
+// src/transport/http-long-polling-transport.ts
+import { SyncError as SyncError3 } from "@korajs/core";
+var DEFAULT_RETRY_DELAY_MS = 250;
+var HttpLongPollingTransport = class {
+  serializer;
+  fetchImpl;
+  retryDelayMs;
+  preferWebSocket;
+  webSocketFactory;
+  messageHandler = null;
+  closeHandler = null;
+  errorHandler = null;
+  connected = false;
+  polling = false;
+  url = null;
+  authToken;
+  pollAbort = null;
+  upgradedTransport = null;
+  constructor(options) {
+    this.serializer = options?.serializer ?? new NegotiatedMessageSerializer("json");
+    this.fetchImpl = options?.fetchImpl ?? fetch;
+    this.retryDelayMs = options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+    this.preferWebSocket = options?.preferWebSocket ?? true;
+    this.webSocketFactory = options?.webSocketFactory ?? (() => new WebSocketTransport({ serializer: this.serializer }));
+  }
+  async connect(url, options) {
+    if (this.connected) {
+      throw new SyncError3("HTTP long-poll transport already connected", { url });
+    }
+    this.url = normalizeHttpUrl(url);
+    this.authToken = options?.authToken;
+    if (this.preferWebSocket) {
+      const upgraded = await this.tryUpgradeToWebSocket(url, options);
+      if (upgraded) {
+        this.upgradedTransport = upgraded;
+        this.connected = true;
+        return;
+      }
+    }
+    this.connected = true;
+    this.polling = true;
+    this.pollAbort = new AbortController();
+    void this.runPollLoop();
+  }
+  async disconnect() {
+    if (this.upgradedTransport) {
+      await this.upgradedTransport.disconnect();
+      this.upgradedTransport = null;
+    }
+    this.connected = false;
+    this.polling = false;
+    this.pollAbort?.abort();
+    this.pollAbort = null;
+    this.url = null;
+  }
+  send(message) {
+    if (!this.connected) {
+      throw new SyncError3("Cannot send message: HTTP long-poll transport is not connected", {
+        messageType: message.type
+      });
+    }
+    if (this.upgradedTransport) {
+      this.upgradedTransport.send(message);
+      return;
+    }
+    void this.postMessage(message);
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+    if (this.upgradedTransport) {
+      this.upgradedTransport.onMessage(handler);
+    }
+  }
+  onClose(handler) {
+    this.closeHandler = handler;
+    if (this.upgradedTransport) {
+      this.upgradedTransport.onClose(handler);
+    }
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+    if (this.upgradedTransport) {
+      this.upgradedTransport.onError(handler);
+    }
+  }
+  isConnected() {
+    if (this.upgradedTransport) {
+      return this.upgradedTransport.isConnected();
+    }
+    return this.connected;
+  }
+  async tryUpgradeToWebSocket(url, options) {
+    const wsTransport = this.webSocketFactory();
+    if (this.messageHandler) wsTransport.onMessage(this.messageHandler);
+    if (this.closeHandler) wsTransport.onClose(this.closeHandler);
+    if (this.errorHandler) wsTransport.onError(this.errorHandler);
+    try {
+      await wsTransport.connect(normalizeWebSocketUrl(url), options);
+      return wsTransport;
+    } catch {
+      return null;
+    }
+  }
+  async postMessage(message) {
+    if (!this.url) return;
+    const encoded = this.serializer.encode(message);
+    const headers = new Headers();
+    headers.set("accept", "application/json, application/x-protobuf");
+    if (this.authToken) {
+      headers.set("authorization", `Bearer ${this.authToken}`);
+    }
+    const isBinary = encoded instanceof Uint8Array;
+    headers.set("content-type", isBinary ? "application/x-protobuf" : "application/json");
+    try {
+      const requestBody = isBinary ? toArrayBuffer(encoded) : encoded;
+      const response = await this.fetchImpl(this.url, {
+        method: "POST",
+        headers,
+        body: requestBody
+      });
+      if (!response.ok) {
+        throw new SyncError3("HTTP transport send failed", {
+          status: response.status,
+          messageType: message.type
+        });
+      }
+    } catch (error) {
+      this.errorHandler?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  async runPollLoop() {
+    while (this.polling && this.connected && this.url) {
+      try {
+        const response = await this.fetchImpl(this.url, {
+          method: "GET",
+          headers: this.makePollHeaders(),
+          signal: this.pollAbort?.signal
+        });
+        if (response.status === 204) {
+          await sleep(this.retryDelayMs);
+          continue;
+        }
+        if (!response.ok) {
+          throw new SyncError3("HTTP long-poll request failed", {
+            status: response.status
+          });
+        }
+        const payload = await readResponsePayload(response);
+        if (payload === null) {
+          continue;
+        }
+        const message = this.serializer.decode(payload);
+        this.messageHandler?.(message);
+      } catch (error) {
+        if (!this.connected || !this.polling) {
+          break;
+        }
+        if (isAbortError(error)) {
+          break;
+        }
+        this.errorHandler?.(error instanceof Error ? error : new Error(String(error)));
+        await sleep(this.retryDelayMs);
+      }
+    }
+    if (!this.connected) {
+      this.closeHandler?.("http long-polling disconnected");
+    }
+  }
+  makePollHeaders() {
+    const headers = new Headers();
+    headers.set("accept", "application/json, application/x-protobuf");
+    if (this.authToken) {
+      headers.set("authorization", `Bearer ${this.authToken}`);
+    }
+    return headers;
+  }
+};
+function normalizeHttpUrl(url) {
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  }
+  if (url.startsWith("ws://")) {
+    return `http://${url.slice("ws://".length)}`;
+  }
+  if (url.startsWith("wss://")) {
+    return `https://${url.slice("wss://".length)}`;
+  }
+  return url;
+}
+function normalizeWebSocketUrl(url) {
+  if (url.startsWith("ws://") || url.startsWith("wss://")) {
+    return url;
+  }
+  if (url.startsWith("http://")) {
+    return `ws://${url.slice("http://".length)}`;
+  }
+  if (url.startsWith("https://")) {
+    return `wss://${url.slice("https://".length)}`;
+  }
+  return url;
+}
+async function readResponsePayload(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/x-protobuf")) {
+    const buffer = await response.arrayBuffer();
+    if (buffer.byteLength === 0) return null;
+    return new Uint8Array(buffer);
+  }
+  const text = await response.text();
+  if (text.length === 0) return null;
+  return text;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAbortError(error) {
+  return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+function toArrayBuffer(data) {
+  const copied = new Uint8Array(data.byteLength);
+  copied.set(data);
+  return copied.buffer;
+}
+
+// src/transport/chaos-transport.ts
+var ChaosTransport = class {
+  inner;
+  dropRate;
+  duplicateRate;
+  reorderRate;
+  maxLatency;
+  random;
+  messageHandler = null;
+  reorderBuffer = [];
+  timers = [];
+  constructor(inner, config) {
+    this.inner = inner;
+    this.dropRate = config?.dropRate ?? 0;
+    this.duplicateRate = config?.duplicateRate ?? 0;
+    this.reorderRate = config?.reorderRate ?? 0;
+    this.maxLatency = config?.maxLatency ?? 0;
+    this.random = config?.randomSource ?? Math.random;
+  }
+  async connect(url, options) {
+    this.inner.onMessage((msg) => this.handleIncoming(msg));
+    return this.inner.connect(url, options);
+  }
+  async disconnect() {
+    this.flushReorderBuffer();
+    for (const timer of this.timers) {
+      clearTimeout(timer);
+    }
+    this.timers = [];
+    return this.inner.disconnect();
+  }
+  send(message) {
+    if (this.random() < this.dropRate) {
+      return;
+    }
+    if (this.random() < this.reorderRate) {
+      this.reorderBuffer.push(message);
+      return;
+    }
+    this.flushReorderBuffer();
+    this.inner.send(message);
+    if (this.random() < this.duplicateRate) {
+      this.inner.send(message);
+    }
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onClose(handler) {
+    this.inner.onClose(handler);
+  }
+  onError(handler) {
+    this.inner.onError(handler);
+  }
+  isConnected() {
+    return this.inner.isConnected();
+  }
+  handleIncoming(message) {
+    if (!this.messageHandler) return;
+    if (this.random() < this.dropRate) {
+      return;
+    }
+    if (this.maxLatency > 0) {
+      const delay = Math.floor(this.random() * this.maxLatency);
+      const timer = setTimeout(() => {
+        this.deliverIncoming(message);
+      }, delay);
+      this.timers.push(timer);
+      return;
+    }
+    this.deliverIncoming(message);
+  }
+  deliverIncoming(message) {
+    if (!this.messageHandler) return;
+    this.messageHandler(message);
+    if (this.random() < this.duplicateRate) {
+      this.messageHandler(message);
+    }
+  }
+  flushReorderBuffer() {
+    const buffer = [...this.reorderBuffer];
+    this.reorderBuffer = [];
+    for (let i = buffer.length - 1; i > 0; i--) {
+      const j = Math.floor(this.random() * (i + 1));
+      const temp = buffer[i];
+      buffer[i] = buffer[j];
+      buffer[j] = temp;
+    }
+    for (const msg of buffer) {
+      this.inner.send(msg);
+    }
+  }
+};
+
+// src/engine/sync-engine.ts
+import { SyncError as SyncError4 } from "@korajs/core";
+import { topologicalSort as topologicalSort2 } from "@korajs/core/internal";
+
+// src/engine/outbound-queue.ts
+import { topologicalSort } from "@korajs/core/internal";
+var OutboundQueue = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  storage;
+  queue = [];
+  seen = /* @__PURE__ */ new Set();
+  inFlight = /* @__PURE__ */ new Map();
+  nextBatchId = 0;
+  initialized = false;
+  /**
+   * Load persisted operations from storage.
+   * Must be called before using the queue.
+   */
+  async initialize() {
+    const stored = await this.storage.load();
+    for (const op of stored) {
+      if (!this.seen.has(op.id)) {
+        this.seen.add(op.id);
+        this.queue.push(op);
+      }
+    }
+    if (this.queue.length > 1) {
+      this.queue = topologicalSort(this.queue);
+    }
+    this.initialized = true;
+  }
+  /**
+   * Add an operation to the outbound queue.
+   * Deduplicates by operation ID. Persists to storage.
+   */
+  async enqueue(op) {
+    if (this.seen.has(op.id)) return;
+    this.seen.add(op.id);
+    this.queue.push(op);
+    await this.storage.enqueue(op);
+    if (this.queue.length > 1) {
+      this.queue = topologicalSort(this.queue);
+    }
+  }
+  /**
+   * Take a batch of operations from the front of the queue.
+   * Moves them to in-flight status. Returns null if queue is empty.
+   *
+   * @param batchSize - Maximum number of operations in the batch
+   */
+  takeBatch(batchSize) {
+    if (this.queue.length === 0) return null;
+    const ops = this.queue.splice(0, batchSize);
+    const batchId = `batch-${this.nextBatchId++}`;
+    this.inFlight.set(batchId, ops);
+    return { batchId, operations: ops };
+  }
+  /**
+   * Acknowledge a batch, removing its operations permanently.
+   */
+  async acknowledge(batchId) {
+    const ops = this.inFlight.get(batchId);
+    if (!ops) return;
+    this.inFlight.delete(batchId);
+    const ids = ops.map((op) => op.id);
+    await this.storage.dequeue(ids);
+  }
+  /**
+   * Return a failed batch to the front of the queue for retry.
+   * Prepends the operations to maintain priority.
+   */
+  returnBatch(batchId) {
+    const ops = this.inFlight.get(batchId);
+    if (!ops) return;
+    this.inFlight.delete(batchId);
+    this.queue.unshift(...ops);
+    if (this.queue.length > 1) {
+      this.queue = topologicalSort(this.queue);
+    }
+  }
+  /**
+   * Number of operations waiting in the queue (not counting in-flight).
+   */
+  get size() {
+    return this.queue.length;
+  }
+  /**
+   * Total operations including in-flight.
+   */
+  get totalPending() {
+    let inFlightCount = 0;
+    for (const ops of this.inFlight.values()) {
+      inFlightCount += ops.length;
+    }
+    return this.queue.length + inFlightCount;
+  }
+  /**
+   * Whether the queue has any operations to send.
+   */
+  get hasOperations() {
+    return this.queue.length > 0;
+  }
+  /**
+   * Peek at the first `count` operations without removing them.
+   */
+  peek(count) {
+    return this.queue.slice(0, count);
+  }
+  /**
+   * Whether initialize() has been called.
+   */
+  get isInitialized() {
+    return this.initialized;
+  }
+};
+
+// src/engine/sync-engine.ts
+var DEFAULT_BATCH_SIZE = 100;
+var DEFAULT_SCHEMA_VERSION = 1;
+var VALID_TRANSITIONS = {
+  disconnected: ["connecting"],
+  connecting: ["handshaking", "error", "disconnected"],
+  handshaking: ["syncing", "error", "disconnected"],
+  syncing: ["streaming", "error", "disconnected"],
+  streaming: ["disconnected", "error"],
+  error: ["disconnected"]
+};
+var nextMessageId = 0;
+function generateMessageId() {
+  return `msg-${Date.now()}-${nextMessageId++}`;
+}
+var SyncEngine = class {
+  state = "disconnected";
+  transport;
+  store;
+  config;
+  serializer;
+  emitter;
+  outboundQueue;
+  batchSize;
+  remoteVector = /* @__PURE__ */ new Map();
+  lastSyncedAt = null;
+  currentBatch = null;
+  // Track delta exchange state
+  deltaBatchesReceived = 0;
+  deltaReceiveComplete = false;
+  deltaSendComplete = false;
+  constructor(options) {
+    this.transport = options.transport;
+    this.store = options.store;
+    this.config = options.config;
+    this.serializer = options.serializer ?? new NegotiatedMessageSerializer("json");
+    this.emitter = options.emitter ?? null;
+    this.batchSize = options.config.batchSize ?? DEFAULT_BATCH_SIZE;
+    const queueStorage = options.queueStorage ?? new MemoryQueueStorage();
+    this.outboundQueue = new OutboundQueue(queueStorage);
+  }
+  /**
+   * Start the sync engine: connect → handshake → delta exchange → streaming.
+   */
+  async start() {
+    if (this.state !== "disconnected") {
+      throw new SyncError4("Cannot start sync engine: not in disconnected state", {
+        currentState: this.state
+      });
+    }
+    await this.outboundQueue.initialize();
+    this.transport.onMessage((msg) => this.handleMessage(msg));
+    this.transport.onClose((reason) => this.handleTransportClose(reason));
+    this.transport.onError((err) => this.handleTransportError(err));
+    this.transitionTo("connecting");
+    try {
+      const authToken = this.config.auth ? (await this.config.auth()).token : void 0;
+      await this.transport.connect(this.config.url, { authToken });
+      this.transitionTo("handshaking");
+      const localVector = this.store.getVersionVector();
+      const handshake = {
+        type: "handshake",
+        messageId: generateMessageId(),
+        nodeId: this.store.getNodeId(),
+        versionVector: versionVectorToWire(localVector),
+        schemaVersion: this.config.schemaVersion ?? DEFAULT_SCHEMA_VERSION,
+        authToken,
+        supportedWireFormats: ["json", "protobuf"]
+      };
+      this.transport.send(handshake);
+    } catch (err) {
+      this.transitionTo("error");
+      this.transitionTo("disconnected");
+      throw err;
+    }
+  }
+  /**
+   * Stop the sync engine. Disconnects the transport.
+   */
+  async stop() {
+    if (this.state === "disconnected") return;
+    if (this.currentBatch) {
+      this.outboundQueue.returnBatch(this.currentBatch.batchId);
+      this.currentBatch = null;
+    }
+    try {
+      await this.transport.disconnect();
+    } finally {
+      this.ensureDisconnected();
+    }
+  }
+  ensureDisconnected() {
+    if (this.state !== "disconnected") {
+      this.transitionTo("disconnected");
+    }
+  }
+  /**
+   * Push a local operation to the outbound queue.
+   * If streaming, flushes immediately.
+   */
+  async pushOperation(op) {
+    await this.outboundQueue.enqueue(op);
+    if (this.state === "streaming") {
+      this.flushQueue();
+    }
+  }
+  /**
+   * Get the current developer-facing sync status.
+   */
+  getStatus() {
+    const pendingOperations = this.outboundQueue.totalPending;
+    switch (this.state) {
+      case "disconnected":
+        return { status: "offline", pendingOperations, lastSyncedAt: this.lastSyncedAt };
+      case "connecting":
+      case "handshaking":
+      case "syncing":
+        return { status: "syncing", pendingOperations, lastSyncedAt: this.lastSyncedAt };
+      case "streaming":
+        return {
+          status: pendingOperations > 0 ? "syncing" : "synced",
+          pendingOperations,
+          lastSyncedAt: this.lastSyncedAt
+        };
+      case "error":
+        return { status: "error", pendingOperations, lastSyncedAt: this.lastSyncedAt };
+    }
+  }
+  /**
+   * Get the current internal state (for testing).
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get the outbound queue (for testing).
+   */
+  getOutboundQueue() {
+    return this.outboundQueue;
+  }
+  // --- Private methods ---
+  handleMessage(message) {
+    switch (message.type) {
+      case "handshake-response":
+        this.handleHandshakeResponse(message);
+        break;
+      case "operation-batch":
+        this.handleOperationBatch(message);
+        break;
+      case "acknowledgment":
+        this.handleAcknowledgment(message);
+        break;
+      case "error":
+        this.handleError(message);
+        break;
+    }
+  }
+  handleHandshakeResponse(msg) {
+    if (this.state !== "handshaking") return;
+    if (!msg.accepted) {
+      this.transitionTo("error");
+      this.emitter?.emit({
+        type: "sync:disconnected",
+        reason: msg.rejectReason ?? "Handshake rejected"
+      });
+      this.transitionTo("disconnected");
+      return;
+    }
+    this.remoteVector = wireToVersionVector(msg.versionVector);
+    if (msg.selectedWireFormat) {
+      this.setSerializerWireFormat(msg.selectedWireFormat);
+    }
+    this.emitter?.emit({ type: "sync:connected", nodeId: this.store.getNodeId() });
+    this.transitionTo("syncing");
+    this.deltaBatchesReceived = 0;
+    this.deltaReceiveComplete = false;
+    this.deltaSendComplete = false;
+    this.sendDelta();
+  }
+  async sendDelta() {
+    const localVector = this.store.getVersionVector();
+    const missingOps = await this.collectDelta(localVector, this.remoteVector);
+    if (missingOps.length === 0) {
+      const emptyBatch = {
+        type: "operation-batch",
+        messageId: generateMessageId(),
+        operations: [],
+        isFinal: true,
+        batchIndex: 0
+      };
+      this.transport.send(emptyBatch);
+      this.deltaSendComplete = true;
+      this.checkDeltaComplete();
+      return;
+    }
+    const sorted = topologicalSort2(missingOps);
+    const totalBatches = Math.ceil(sorted.length / this.batchSize);
+    for (let i = 0; i < totalBatches; i++) {
+      const start = i * this.batchSize;
+      const batchOps = sorted.slice(start, start + this.batchSize);
+      const serializedOps = batchOps.map((op) => this.serializer.encodeOperation(op));
+      const batchMsg = {
+        type: "operation-batch",
+        messageId: generateMessageId(),
+        operations: serializedOps,
+        isFinal: i === totalBatches - 1,
+        batchIndex: i
+      };
+      this.transport.send(batchMsg);
+      this.emitter?.emit({
+        type: "sync:sent",
+        operations: batchOps,
+        batchSize: batchOps.length
+      });
+    }
+    this.deltaSendComplete = true;
+    this.checkDeltaComplete();
+  }
+  async collectDelta(localVector, remoteVector) {
+    const missing = [];
+    for (const [nodeId, localSeq] of localVector) {
+      const remoteSeq = remoteVector.get(nodeId) ?? 0;
+      if (localSeq > remoteSeq) {
+        const ops = await this.store.getOperationRange(nodeId, remoteSeq + 1, localSeq);
+        missing.push(...ops);
+      }
+    }
+    return missing;
+  }
+  async handleOperationBatch(msg) {
+    const operations = msg.operations.map((s) => this.serializer.decodeOperation(s));
+    for (const op of operations) {
+      await this.store.applyRemoteOperation(op);
+    }
+    if (operations.length > 0) {
+      this.emitter?.emit({
+        type: "sync:received",
+        operations,
+        batchSize: operations.length
+      });
+    }
+    const lastOp = operations[operations.length - 1];
+    const ack = {
+      type: "acknowledgment",
+      messageId: generateMessageId(),
+      acknowledgedMessageId: msg.messageId,
+      lastSequenceNumber: lastOp ? lastOp.sequenceNumber : 0
+    };
+    this.transport.send(ack);
+    this.emitter?.emit({
+      type: "sync:acknowledged",
+      sequenceNumber: lastOp ? lastOp.sequenceNumber : 0
+    });
+    if (this.state === "syncing") {
+      this.deltaBatchesReceived++;
+      if (msg.isFinal) {
+        this.deltaReceiveComplete = true;
+        this.checkDeltaComplete();
+      }
+    }
+  }
+  handleAcknowledgment(msg) {
+    if (this.currentBatch) {
+      this.outboundQueue.acknowledge(this.currentBatch.batchId);
+      this.currentBatch = null;
+      this.lastSyncedAt = Date.now();
+    }
+    if (this.state === "streaming" && this.outboundQueue.hasOperations) {
+      this.flushQueue();
+    }
+  }
+  handleError(msg) {
+    this.transitionTo("error");
+    this.emitter?.emit({ type: "sync:disconnected", reason: msg.message });
+    this.transitionTo("disconnected");
+  }
+  checkDeltaComplete() {
+    if (this.deltaSendComplete && this.deltaReceiveComplete) {
+      this.lastSyncedAt = Date.now();
+      this.transitionTo("streaming");
+      if (this.outboundQueue.hasOperations) {
+        this.flushQueue();
+      }
+    }
+  }
+  flushQueue() {
+    if (this.currentBatch) return;
+    if (!this.outboundQueue.hasOperations) return;
+    const batch = this.outboundQueue.takeBatch(this.batchSize);
+    if (!batch) return;
+    this.currentBatch = batch;
+    const serializedOps = batch.operations.map((op) => this.serializer.encodeOperation(op));
+    const batchMsg = {
+      type: "operation-batch",
+      messageId: generateMessageId(),
+      operations: serializedOps,
+      isFinal: true,
+      batchIndex: 0
+    };
+    this.transport.send(batchMsg);
+    this.emitter?.emit({
+      type: "sync:sent",
+      operations: batch.operations,
+      batchSize: batch.operations.length
+    });
+  }
+  handleTransportClose(reason) {
+    if (this.currentBatch) {
+      this.outboundQueue.returnBatch(this.currentBatch.batchId);
+      this.currentBatch = null;
+    }
+    if (this.state !== "disconnected") {
+      this.emitter?.emit({ type: "sync:disconnected", reason });
+      this.transitionTo("disconnected");
+    }
+  }
+  handleTransportError(err) {
+    if (this.state !== "disconnected") {
+      this.transitionTo("error");
+      this.emitter?.emit({ type: "sync:disconnected", reason: err.message });
+      this.transitionTo("disconnected");
+    }
+  }
+  transitionTo(newState) {
+    const validTargets = VALID_TRANSITIONS[this.state];
+    if (!validTargets.includes(newState)) {
+      throw new SyncError4(`Invalid sync state transition: ${this.state} \u2192 ${newState}`, {
+        from: this.state,
+        to: newState
+      });
+    }
+    this.state = newState;
+  }
+  setSerializerWireFormat(format) {
+    if (typeof this.serializer.setWireFormat === "function") {
+      this.serializer.setWireFormat(format);
+    }
+  }
+};
+
+// src/engine/connection-monitor.ts
+var ConnectionMonitor = class {
+  windowSize;
+  staleThreshold;
+  timeSource;
+  latencies = [];
+  missedAcks = 0;
+  lastActivityTime;
+  constructor(config) {
+    this.windowSize = config?.windowSize ?? 20;
+    this.staleThreshold = config?.staleThreshold ?? 3e4;
+    this.timeSource = config?.timeSource ?? { now: () => Date.now() };
+    this.lastActivityTime = this.timeSource.now();
+  }
+  /**
+   * Record a round-trip time sample.
+   */
+  recordLatency(ms) {
+    this.latencies.push(ms);
+    if (this.latencies.length > this.windowSize) {
+      this.latencies.shift();
+    }
+    this.lastActivityTime = this.timeSource.now();
+    this.missedAcks = 0;
+  }
+  /**
+   * Record a missed acknowledgment (message sent but no response received).
+   */
+  recordMissedAck() {
+    this.missedAcks++;
+  }
+  /**
+   * Record any activity (message sent or received).
+   */
+  recordActivity() {
+    this.lastActivityTime = this.timeSource.now();
+  }
+  /**
+   * Assess current connection quality based on collected metrics.
+   *
+   * Quality thresholds (average RTT):
+   * - excellent: < 100ms, 0 missed acks
+   * - good: < 300ms, ≤ 1 missed ack
+   * - fair: < 1000ms, ≤ 3 missed acks
+   * - poor: < 5000ms or > 3 missed acks
+   * - offline: no activity for staleThreshold ms
+   */
+  getQuality() {
+    const elapsed = this.timeSource.now() - this.lastActivityTime;
+    if (elapsed > this.staleThreshold) return "offline";
+    if (this.latencies.length === 0) {
+      return this.missedAcks > 3 ? "poor" : "good";
+    }
+    const avgLatency = this.latencies.reduce((sum, l) => sum + l, 0) / this.latencies.length;
+    if (this.missedAcks > 3) return "poor";
+    if (avgLatency < 100 && this.missedAcks === 0) return "excellent";
+    if (avgLatency < 300 && this.missedAcks <= 1) return "good";
+    if (avgLatency < 1e3 && this.missedAcks <= 3) return "fair";
+    return "poor";
+  }
+  /**
+   * Reset all metrics. Call on disconnect.
+   */
+  reset() {
+    this.latencies = [];
+    this.missedAcks = 0;
+    this.lastActivityTime = this.timeSource.now();
+  }
+  /**
+   * Get the current average latency in ms. Returns null if no samples.
+   */
+  getAverageLatency() {
+    if (this.latencies.length === 0) return null;
+    return this.latencies.reduce((sum, l) => sum + l, 0) / this.latencies.length;
+  }
+  /**
+   * Get the number of missed acks.
+   */
+  getMissedAcks() {
+    return this.missedAcks;
+  }
+};
+
+// src/engine/reconnection-manager.ts
+var ReconnectionManager = class {
+  initialDelay;
+  maxDelay;
+  multiplier;
+  maxAttempts;
+  jitter;
+  random;
+  attempt = 0;
+  timer = null;
+  stopped = false;
+  waitResolve = null;
+  constructor(config) {
+    this.initialDelay = config?.initialDelay ?? 1e3;
+    this.maxDelay = config?.maxDelay ?? 3e4;
+    this.multiplier = config?.multiplier ?? 2;
+    this.maxAttempts = config?.maxAttempts ?? 0;
+    this.jitter = config?.jitter ?? 0.25;
+    this.random = config?.randomSource ?? Math.random;
+  }
+  /**
+   * Start reconnection attempts. Calls `onReconnect` with exponential backoff.
+   *
+   * @param onReconnect - Called on each attempt. Return `true` if reconnection succeeded.
+   * @returns Promise that resolves when reconnection succeeds or maxAttempts reached.
+   */
+  async start(onReconnect) {
+    this.stopped = false;
+    this.attempt = 0;
+    while (!this.stopped) {
+      if (this.maxAttempts > 0 && this.attempt >= this.maxAttempts) {
+        return false;
+      }
+      const delay = this.getNextDelay();
+      this.attempt++;
+      await this.wait(delay);
+      if (this.stopped) return false;
+      try {
+        const success = await onReconnect();
+        if (success) {
+          this.reset();
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  /**
+   * Stop any pending reconnection attempt.
+   */
+  stop() {
+    this.stopped = true;
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.waitResolve) {
+      this.waitResolve();
+      this.waitResolve = null;
+    }
+  }
+  /**
+   * Reset the attempt counter. Call after a successful manual reconnection.
+   */
+  reset() {
+    this.attempt = 0;
+    this.stopped = false;
+  }
+  /**
+   * Compute the next delay for the current attempt.
+   * Exposed for testing purposes.
+   */
+  getNextDelay() {
+    const baseDelay = Math.min(this.initialDelay * this.multiplier ** this.attempt, this.maxDelay);
+    const jitterRange = baseDelay * this.jitter;
+    const jitterOffset = (this.random() - 0.5) * 2 * jitterRange;
+    return Math.max(0, Math.round(baseDelay + jitterOffset));
+  }
+  /**
+   * Current attempt number (for testing).
+   */
+  getAttemptCount() {
+    return this.attempt;
+  }
+  wait(ms) {
+    return new Promise((resolve) => {
+      this.waitResolve = resolve;
+      this.timer = setTimeout(() => {
+        this.timer = null;
+        this.waitResolve = null;
+        resolve();
+      }, ms);
+    });
+  }
+};
+export {
+  ChaosTransport,
+  ConnectionMonitor,
+  HttpLongPollingTransport,
+  JsonMessageSerializer,
+  NegotiatedMessageSerializer,
+  OutboundQueue,
+  ProtobufMessageSerializer,
+  ReconnectionManager,
+  SYNC_STATES,
+  SYNC_STATUSES,
+  SyncEngine,
+  WebSocketTransport,
+  isAcknowledgmentMessage,
+  isErrorMessage,
+  isHandshakeMessage,
+  isHandshakeResponseMessage,
+  isOperationBatchMessage,
+  isSyncMessage,
+  versionVectorToWire,
+  wireToVersionVector
+};
+//# sourceMappingURL=index.js.map