@korajs/sync 0.1.0

package/dist/internal.js

@@ -0,0 +1,102 @@
+import {
+  MemoryQueueStorage
+} from "./chunk-TU345YUC.js";
+
+// src/transport/memory-transport.ts
+import { SyncError } from "@korajs/core";
+var MemoryTransport = class {
+  connected = false;
+  messageHandler = null;
+  closeHandler = null;
+  errorHandler = null;
+  peer = null;
+  sentMessages = [];
+  /** Link this transport to its peer (the other end of the connection) */
+  linkPeer(peer) {
+    this.peer = peer;
+  }
+  async connect(_url, _options) {
+    if (!this.peer) {
+      throw new SyncError("MemoryTransport has no linked peer", {
+        reason: "not-linked"
+      });
+    }
+    this.connected = true;
+    this.peer.connected = true;
+  }
+  async disconnect() {
+    if (!this.connected) return;
+    this.connected = false;
+    if (this.peer?.connected) {
+      this.peer.connected = false;
+      this.peer.closeHandler?.("peer disconnected");
+    }
+  }
+  send(message) {
+    if (!this.connected) {
+      throw new SyncError("Cannot send message: transport is not connected", {
+        messageType: message.type
+      });
+    }
+    this.sentMessages.push(message);
+    this.peer?.messageHandler?.(message);
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onClose(handler) {
+    this.closeHandler = handler;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  // --- Testing helpers ---
+  /**
+   * Simulate an incoming message (as if received from peer).
+   * Useful for testing without a linked peer.
+   */
+  simulateIncoming(message) {
+    this.messageHandler?.(message);
+  }
+  /**
+   * Simulate a disconnect from the remote side.
+   */
+  simulateDisconnect(reason) {
+    this.connected = false;
+    this.closeHandler?.(reason);
+  }
+  /**
+   * Simulate a transport error.
+   */
+  simulateError(error) {
+    this.errorHandler?.(error);
+  }
+  /**
+   * Get all messages sent through this transport.
+   */
+  getSentMessages() {
+    return [...this.sentMessages];
+  }
+  /**
+   * Clear the sent messages history.
+   */
+  clearSentMessages() {
+    this.sentMessages.length = 0;
+  }
+};
+function createMemoryTransportPair() {
+  const client = new MemoryTransport();
+  const server = new MemoryTransport();
+  client.linkPeer(server);
+  server.linkPeer(client);
+  return { client, server };
+}
+export {
+  MemoryQueueStorage,
+  MemoryTransport,
+  createMemoryTransportPair
+};
+//# sourceMappingURL=internal.js.map

package/dist/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transport/memory-transport.ts"],"sourcesContent":["import { SyncError } from '@korajs/core'\nimport type { SyncMessage } from '../protocol/messages'\nimport type {\n\tSyncTransport,\n\tTransportCloseHandler,\n\tTransportErrorHandler,\n\tTransportMessageHandler,\n\tTransportOptions,\n} from './transport'\n\n/**\n * In-memory transport for testing. Provides instant, synchronous message delivery\n * between a linked pair of transports (simulating client ↔ server).\n */\nexport class MemoryTransport implements SyncTransport {\n\tprivate connected = false\n\tprivate messageHandler: TransportMessageHandler | null = null\n\tprivate closeHandler: TransportCloseHandler | null = null\n\tprivate errorHandler: TransportErrorHandler | null = null\n\tprivate peer: MemoryTransport | null = null\n\tprivate readonly sentMessages: SyncMessage[] = []\n\n\t/** Link this transport to its peer (the other end of the connection) */\n\tlinkPeer(peer: MemoryTransport): void {\n\t\tthis.peer = peer\n\t}\n\n\tasync connect(_url: string, _options?: TransportOptions): Promise<void> {\n\t\tif (!this.peer) {\n\t\t\tthrow new SyncError('MemoryTransport has no linked peer', {\n\t\t\t\treason: 'not-linked',\n\t\t\t})\n\t\t}\n\t\tthis.connected = true\n\t\tthis.peer.connected = true\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return\n\t\tthis.connected = false\n\t\t// Notify peer that we disconnected\n\t\tif (this.peer?.connected) {\n\t\t\tthis.peer.connected = false\n\t\t\tthis.peer.closeHandler?.('peer disconnected')\n\t\t}\n\t}\n\n\tsend(message: SyncMessage): void {\n\t\tif (!this.connected) {\n\t\t\tthrow new SyncError('Cannot send message: transport is not connected', {\n\t\t\t\tmessageType: message.type,\n\t\t\t})\n\t\t}\n\t\tthis.sentMessages.push(message)\n\t\t// Deliver to peer's message handler\n\t\tthis.peer?.messageHandler?.(message)\n\t}\n\n\tonMessage(handler: TransportMessageHandler): void {\n\t\tthis.messageHandler = handler\n\t}\n\n\tonClose(handler: TransportCloseHandler): void {\n\t\tthis.closeHandler = handler\n\t}\n\n\tonError(handler: TransportErrorHandler): void {\n\t\tthis.errorHandler = handler\n\t}\n\n\tisConnected(): boolean {\n\t\treturn this.connected\n\t}\n\n\t// --- Testing helpers ---\n\n\t/**\n\t * Simulate an incoming message (as if received from peer).\n\t * Useful for testing without a linked peer.\n\t */\n\tsimulateIncoming(message: SyncMessage): void {\n\t\tthis.messageHandler?.(message)\n\t}\n\n\t/**\n\t * Simulate a disconnect from the remote side.\n\t */\n\tsimulateDisconnect(reason: string): void {\n\t\tthis.connected = false\n\t\tthis.closeHandler?.(reason)\n\t}\n\n\t/**\n\t * Simulate a transport error.\n\t */\n\tsimulateError(error: Error): void {\n\t\tthis.errorHandler?.(error)\n\t}\n\n\t/**\n\t * Get all messages sent through this transport.\n\t */\n\tgetSentMessages(): SyncMessage[] {\n\t\treturn [...this.sentMessages]\n\t}\n\n\t/**\n\t * Clear the sent messages history.\n\t */\n\tclearSentMessages(): void {\n\t\tthis.sentMessages.length = 0\n\t}\n}\n\n/**\n * Create a linked pair of memory transports for testing.\n * Messages sent on `client` arrive at `server` and vice versa.\n */\nexport function createMemoryTransportPair(): { client: MemoryTransport; server: MemoryTransport } {\n\tconst client = new MemoryTransport()\n\tconst server = new MemoryTransport()\n\tclient.linkPeer(server)\n\tserver.linkPeer(client)\n\treturn { client, server }\n}\n"],"mappings":";;;;;AAAA,SAAS,iBAAiB;AAcnB,IAAM,kBAAN,MAA+C;AAAA,EAC7C,YAAY;AAAA,EACZ,iBAAiD;AAAA,EACjD,eAA6C;AAAA,EAC7C,eAA6C;AAAA,EAC7C,OAA+B;AAAA,EACtB,eAA8B,CAAC;AAAA;AAAA,EAGhD,SAAS,MAA6B;AACrC,SAAK,OAAO;AAAA,EACb;AAAA,EAEA,MAAM,QAAQ,MAAc,UAA4C;AACvE,QAAI,CAAC,KAAK,MAAM;AACf,YAAM,IAAI,UAAU,sCAAsC;AAAA,QACzD,QAAQ;AAAA,MACT,CAAC;AAAA,IACF;AACA,SAAK,YAAY;AACjB,SAAK,KAAK,YAAY;AAAA,EACvB;AAAA,EAEA,MAAM,aAA4B;AACjC,QAAI,CAAC,KAAK,UAAW;AACrB,SAAK,YAAY;AAEjB,QAAI,KAAK,MAAM,WAAW;AACzB,WAAK,KAAK,YAAY;AACtB,WAAK,KAAK,eAAe,mBAAmB;AAAA,IAC7C;AAAA,EACD;AAAA,EAEA,KAAK,SAA4B;AAChC,QAAI,CAAC,KAAK,WAAW;AACpB,YAAM,IAAI,UAAU,mDAAmD;AAAA,QACtE,aAAa,QAAQ;AAAA,MACtB,CAAC;AAAA,IACF;AACA,SAAK,aAAa,KAAK,OAAO;AAE9B,SAAK,MAAM,iBAAiB,OAAO;AAAA,EACpC;AAAA,EAEA,UAAU,SAAwC;AACjD,SAAK,iBAAiB;AAAA,EACvB;AAAA,EAEA,QAAQ,SAAsC;AAC7C,SAAK,eAAe;AAAA,EACrB;AAAA,EAEA,QAAQ,SAAsC;AAC7C,SAAK,eAAe;AAAA,EACrB;AAAA,EAEA,cAAuB;AACtB,WAAO,KAAK;AAAA,EACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,iBAAiB,SAA4B;AAC5C,SAAK,iBAAiB,OAAO;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA,EAKA,mBAAmB,QAAsB;AACxC,SAAK,YAAY;AACjB,SAAK,eAAe,MAAM;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKA,cAAc,OAAoB;AACjC,SAAK,eAAe,KAAK;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA,EAKA,kBAAiC;AAChC,WAAO,CAAC,GAAG,KAAK,YAAY;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA,EAKA,oBAA0B;AACzB,SAAK,aAAa,SAAS;AAAA,EAC5B;AACD;AAMO,SAAS,4BAAkF;AACjG,QAAM,SAAS,IAAI,gBAAgB;AACnC,QAAM,SAAS,IAAI,gBAAgB;AACnC,SAAO,SAAS,MAAM;AACtB,SAAO,SAAS,MAAM;AACtB,SAAO,EAAE,QAAQ,OAAO;AACzB;","names":[]}

package/dist/transport-B5EFsr5F.d.cts

@@ -0,0 +1,215 @@
+import { Operation, OperationType, HLCTimestamp } from '@korajs/core';
+
+/**
+ * Internal sync engine states. Used for state machine transitions.
+ */
+declare const SYNC_STATES: readonly ["disconnected", "connecting", "handshaking", "syncing", "streaming", "error"];
+type SyncState = (typeof SYNC_STATES)[number];
+/**
+ * Developer-facing sync status. Simplified view of the internal state.
+ */
+declare const SYNC_STATUSES: readonly ["connected", "syncing", "synced", "offline", "error"];
+type SyncStatus = (typeof SYNC_STATUSES)[number];
+/**
+ * Sync status information exposed to developers.
+ */
+interface SyncStatusInfo {
+    /** Current developer-facing status */
+    status: SyncStatus;
+    /** Number of operations waiting to be sent */
+    pendingOperations: number;
+    /** Timestamp of last successful sync (null if never synced) */
+    lastSyncedAt: number | null;
+}
+/**
+ * Sync configuration provided by the developer.
+ */
+interface SyncConfig {
+    /** WebSocket or HTTP URL for the sync server */
+    url: string;
+    /** Transport type to use. Defaults to 'websocket'. */
+    transport?: 'websocket' | 'http';
+    /** Auth provider function. Called before each connection attempt. */
+    auth?: () => Promise<{
+        token: string;
+    }>;
+    /** Sync scopes per collection. Limits which records sync to this client. */
+    scopes?: Record<string, (ctx: SyncScopeContext) => Record<string, unknown>>;
+    /** Number of operations per batch. Defaults to 100. */
+    batchSize?: number;
+    /** Initial reconnection delay in ms. Defaults to 1000. */
+    reconnectInterval?: number;
+    /** Maximum reconnection delay in ms. Defaults to 30000. */
+    maxReconnectInterval?: number;
+    /** Schema version of this client. */
+    schemaVersion?: number;
+}
+/**
+ * Context passed to sync scope functions.
+ */
+interface SyncScopeContext {
+    userId?: string;
+    [key: string]: unknown;
+}
+/**
+ * Interface for persisting the outbound operation queue.
+ * Operations must survive page refreshes and be sent when connection is re-established.
+ */
+interface QueueStorage {
+    /** Load all queued operations from persistent storage */
+    load(): Promise<Operation[]>;
+    /** Persist an operation to the queue */
+    enqueue(op: Operation): Promise<void>;
+    /** Remove acknowledged operations by their IDs */
+    dequeue(ids: string[]): Promise<void>;
+    /** Return number of operations in storage */
+    count(): Promise<number>;
+}
+
+type WireFormat = 'json' | 'protobuf';
+/**
+ * Wire-format operation. Plain object (no Map) for JSON serialization.
+ * Maps 1:1 with Operation, but uses Record instead of Map for version vectors.
+ */
+interface SerializedOperation {
+    id: string;
+    nodeId: string;
+    type: OperationType;
+    collection: string;
+    recordId: string;
+    data: Record<string, unknown> | null;
+    previousData: Record<string, unknown> | null;
+    timestamp: HLCTimestamp;
+    sequenceNumber: number;
+    causalDeps: string[];
+    schemaVersion: number;
+}
+/**
+ * Handshake message sent by client to initiate sync.
+ */
+interface HandshakeMessage {
+    type: 'handshake';
+    messageId: string;
+    nodeId: string;
+    /** Version vector as plain object (nodeId -> sequence number) */
+    versionVector: Record<string, number>;
+    schemaVersion: number;
+    authToken?: string;
+    supportedWireFormats?: WireFormat[];
+}
+/**
+ * Server response to a handshake.
+ */
+interface HandshakeResponseMessage {
+    type: 'handshake-response';
+    messageId: string;
+    nodeId: string;
+    versionVector: Record<string, number>;
+    schemaVersion: number;
+    accepted: boolean;
+    rejectReason?: string;
+    selectedWireFormat?: WireFormat;
+}
+/**
+ * Batch of operations sent during delta exchange or streaming.
+ */
+interface OperationBatchMessage {
+    type: 'operation-batch';
+    messageId: string;
+    operations: SerializedOperation[];
+    /** True if this is the last batch in the delta exchange phase */
+    isFinal: boolean;
+    /** Index of this batch (0-based) for ordering */
+    batchIndex: number;
+}
+/**
+ * Acknowledgment of a received message.
+ */
+interface AcknowledgmentMessage {
+    type: 'acknowledgment';
+    messageId: string;
+    acknowledgedMessageId: string;
+    lastSequenceNumber: number;
+}
+/**
+ * Error message from the server or client.
+ */
+interface ErrorMessage {
+    type: 'error';
+    messageId: string;
+    code: string;
+    message: string;
+    retriable: boolean;
+}
+/**
+ * Union of all sync protocol messages.
+ */
+type SyncMessage = HandshakeMessage | HandshakeResponseMessage | OperationBatchMessage | AcknowledgmentMessage | ErrorMessage;
+/**
+ * Check if an unknown value is a valid SyncMessage.
+ */
+declare function isSyncMessage(value: unknown): value is SyncMessage;
+/**
+ * Check if a value is a HandshakeMessage.
+ */
+declare function isHandshakeMessage(value: unknown): value is HandshakeMessage;
+/**
+ * Check if a value is a HandshakeResponseMessage.
+ */
+declare function isHandshakeResponseMessage(value: unknown): value is HandshakeResponseMessage;
+/**
+ * Check if a value is an OperationBatchMessage.
+ */
+declare function isOperationBatchMessage(value: unknown): value is OperationBatchMessage;
+/**
+ * Check if a value is an AcknowledgmentMessage.
+ */
+declare function isAcknowledgmentMessage(value: unknown): value is AcknowledgmentMessage;
+/**
+ * Check if a value is an ErrorMessage.
+ */
+declare function isErrorMessage(value: unknown): value is ErrorMessage;
+
+/**
+ * Options for transport connection.
+ */
+interface TransportOptions {
+    /** Authentication token sent during connection */
+    authToken?: string;
+    /** Additional headers (for HTTP-based transports) */
+    headers?: Record<string, string>;
+}
+/**
+ * Transport-level error handler.
+ */
+type TransportErrorHandler = (error: Error) => void;
+/**
+ * Transport-level close handler.
+ */
+type TransportCloseHandler = (reason: string) => void;
+/**
+ * Transport-level message handler.
+ */
+type TransportMessageHandler = (message: SyncMessage) => void;
+/**
+ * Abstract transport interface for sync communication.
+ * Implementations can use WebSocket, HTTP, Bluetooth, or any other transport.
+ */
+interface SyncTransport {
+    /** Connect to the sync server at the given URL */
+    connect(url: string, options?: TransportOptions): Promise<void>;
+    /** Disconnect from the server */
+    disconnect(): Promise<void>;
+    /** Send a sync message */
+    send(message: SyncMessage): void;
+    /** Register a handler for incoming messages */
+    onMessage(handler: TransportMessageHandler): void;
+    /** Register a handler for connection close events */
+    onClose(handler: TransportCloseHandler): void;
+    /** Register a handler for transport errors */
+    onError(handler: TransportErrorHandler): void;
+    /** Returns true if the transport is currently connected */
+    isConnected(): boolean;
+}
+
+export { type AcknowledgmentMessage as A, type ErrorMessage as E, type HandshakeMessage as H, type OperationBatchMessage as O, type QueueStorage as Q, type SyncMessage as S, type TransportOptions as T, type WireFormat as W, type SerializedOperation as a, type SyncTransport as b, type TransportMessageHandler as c, type TransportCloseHandler as d, type TransportErrorHandler as e, type SyncConfig as f, type SyncStatusInfo as g, type SyncState as h, type HandshakeResponseMessage as i, SYNC_STATES as j, SYNC_STATUSES as k, type SyncScopeContext as l, type SyncStatus as m, isAcknowledgmentMessage as n, isErrorMessage as o, isHandshakeMessage as p, isHandshakeResponseMessage as q, isOperationBatchMessage as r, isSyncMessage as s };

package/dist/transport-B5EFsr5F.d.ts

@@ -0,0 +1,215 @@
+import { Operation, OperationType, HLCTimestamp } from '@korajs/core';
+
+/**
+ * Internal sync engine states. Used for state machine transitions.
+ */
+declare const SYNC_STATES: readonly ["disconnected", "connecting", "handshaking", "syncing", "streaming", "error"];
+type SyncState = (typeof SYNC_STATES)[number];
+/**
+ * Developer-facing sync status. Simplified view of the internal state.
+ */
+declare const SYNC_STATUSES: readonly ["connected", "syncing", "synced", "offline", "error"];
+type SyncStatus = (typeof SYNC_STATUSES)[number];
+/**
+ * Sync status information exposed to developers.
+ */
+interface SyncStatusInfo {
+    /** Current developer-facing status */
+    status: SyncStatus;
+    /** Number of operations waiting to be sent */
+    pendingOperations: number;
+    /** Timestamp of last successful sync (null if never synced) */
+    lastSyncedAt: number | null;
+}
+/**
+ * Sync configuration provided by the developer.
+ */
+interface SyncConfig {
+    /** WebSocket or HTTP URL for the sync server */
+    url: string;
+    /** Transport type to use. Defaults to 'websocket'. */
+    transport?: 'websocket' | 'http';
+    /** Auth provider function. Called before each connection attempt. */
+    auth?: () => Promise<{
+        token: string;
+    }>;
+    /** Sync scopes per collection. Limits which records sync to this client. */
+    scopes?: Record<string, (ctx: SyncScopeContext) => Record<string, unknown>>;
+    /** Number of operations per batch. Defaults to 100. */
+    batchSize?: number;
+    /** Initial reconnection delay in ms. Defaults to 1000. */
+    reconnectInterval?: number;
+    /** Maximum reconnection delay in ms. Defaults to 30000. */
+    maxReconnectInterval?: number;
+    /** Schema version of this client. */
+    schemaVersion?: number;
+}
+/**
+ * Context passed to sync scope functions.
+ */
+interface SyncScopeContext {
+    userId?: string;
+    [key: string]: unknown;
+}
+/**
+ * Interface for persisting the outbound operation queue.
+ * Operations must survive page refreshes and be sent when connection is re-established.
+ */
+interface QueueStorage {
+    /** Load all queued operations from persistent storage */
+    load(): Promise<Operation[]>;
+    /** Persist an operation to the queue */
+    enqueue(op: Operation): Promise<void>;
+    /** Remove acknowledged operations by their IDs */
+    dequeue(ids: string[]): Promise<void>;
+    /** Return number of operations in storage */
+    count(): Promise<number>;
+}
+
+type WireFormat = 'json' | 'protobuf';
+/**
+ * Wire-format operation. Plain object (no Map) for JSON serialization.
+ * Maps 1:1 with Operation, but uses Record instead of Map for version vectors.
+ */
+interface SerializedOperation {
+    id: string;
+    nodeId: string;
+    type: OperationType;
+    collection: string;
+    recordId: string;
+    data: Record<string, unknown> | null;
+    previousData: Record<string, unknown> | null;
+    timestamp: HLCTimestamp;
+    sequenceNumber: number;
+    causalDeps: string[];
+    schemaVersion: number;
+}
+/**
+ * Handshake message sent by client to initiate sync.
+ */
+interface HandshakeMessage {
+    type: 'handshake';
+    messageId: string;
+    nodeId: string;
+    /** Version vector as plain object (nodeId -> sequence number) */
+    versionVector: Record<string, number>;
+    schemaVersion: number;
+    authToken?: string;
+    supportedWireFormats?: WireFormat[];
+}
+/**
+ * Server response to a handshake.
+ */
+interface HandshakeResponseMessage {
+    type: 'handshake-response';
+    messageId: string;
+    nodeId: string;
+    versionVector: Record<string, number>;
+    schemaVersion: number;
+    accepted: boolean;
+    rejectReason?: string;
+    selectedWireFormat?: WireFormat;
+}
+/**
+ * Batch of operations sent during delta exchange or streaming.
+ */
+interface OperationBatchMessage {
+    type: 'operation-batch';
+    messageId: string;
+    operations: SerializedOperation[];
+    /** True if this is the last batch in the delta exchange phase */
+    isFinal: boolean;
+    /** Index of this batch (0-based) for ordering */
+    batchIndex: number;
+}
+/**
+ * Acknowledgment of a received message.
+ */
+interface AcknowledgmentMessage {
+    type: 'acknowledgment';
+    messageId: string;
+    acknowledgedMessageId: string;
+    lastSequenceNumber: number;
+}
+/**
+ * Error message from the server or client.
+ */
+interface ErrorMessage {
+    type: 'error';
+    messageId: string;
+    code: string;
+    message: string;
+    retriable: boolean;
+}
+/**
+ * Union of all sync protocol messages.
+ */
+type SyncMessage = HandshakeMessage | HandshakeResponseMessage | OperationBatchMessage | AcknowledgmentMessage | ErrorMessage;
+/**
+ * Check if an unknown value is a valid SyncMessage.
+ */
+declare function isSyncMessage(value: unknown): value is SyncMessage;
+/**
+ * Check if a value is a HandshakeMessage.
+ */
+declare function isHandshakeMessage(value: unknown): value is HandshakeMessage;
+/**
+ * Check if a value is a HandshakeResponseMessage.
+ */
+declare function isHandshakeResponseMessage(value: unknown): value is HandshakeResponseMessage;
+/**
+ * Check if a value is an OperationBatchMessage.
+ */
+declare function isOperationBatchMessage(value: unknown): value is OperationBatchMessage;
+/**
+ * Check if a value is an AcknowledgmentMessage.
+ */
+declare function isAcknowledgmentMessage(value: unknown): value is AcknowledgmentMessage;
+/**
+ * Check if a value is an ErrorMessage.
+ */
+declare function isErrorMessage(value: unknown): value is ErrorMessage;
+
+/**
+ * Options for transport connection.
+ */
+interface TransportOptions {
+    /** Authentication token sent during connection */
+    authToken?: string;
+    /** Additional headers (for HTTP-based transports) */
+    headers?: Record<string, string>;
+}
+/**
+ * Transport-level error handler.
+ */
+type TransportErrorHandler = (error: Error) => void;
+/**
+ * Transport-level close handler.
+ */
+type TransportCloseHandler = (reason: string) => void;
+/**
+ * Transport-level message handler.
+ */
+type TransportMessageHandler = (message: SyncMessage) => void;
+/**
+ * Abstract transport interface for sync communication.
+ * Implementations can use WebSocket, HTTP, Bluetooth, or any other transport.
+ */
+interface SyncTransport {
+    /** Connect to the sync server at the given URL */
+    connect(url: string, options?: TransportOptions): Promise<void>;
+    /** Disconnect from the server */
+    disconnect(): Promise<void>;
+    /** Send a sync message */
+    send(message: SyncMessage): void;
+    /** Register a handler for incoming messages */
+    onMessage(handler: TransportMessageHandler): void;
+    /** Register a handler for connection close events */
+    onClose(handler: TransportCloseHandler): void;
+    /** Register a handler for transport errors */
+    onError(handler: TransportErrorHandler): void;
+    /** Returns true if the transport is currently connected */
+    isConnected(): boolean;
+}
+
+export { type AcknowledgmentMessage as A, type ErrorMessage as E, type HandshakeMessage as H, type OperationBatchMessage as O, type QueueStorage as Q, type SyncMessage as S, type TransportOptions as T, type WireFormat as W, type SerializedOperation as a, type SyncTransport as b, type TransportMessageHandler as c, type TransportCloseHandler as d, type TransportErrorHandler as e, type SyncConfig as f, type SyncStatusInfo as g, type SyncState as h, type HandshakeResponseMessage as i, SYNC_STATES as j, SYNC_STATUSES as k, type SyncScopeContext as l, type SyncStatus as m, isAcknowledgmentMessage as n, isErrorMessage as o, isHandshakeMessage as p, isHandshakeResponseMessage as q, isOperationBatchMessage as r, isSyncMessage as s };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@korajs/sync",
+  "version": "0.1.0",
+  "description": "Kora.js sync package",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./internal": {
+      "import": {
+        "types": "./dist/internal.d.ts",
+        "default": "./dist/internal.js"
+      },
+      "require": {
+        "types": "./dist/internal.d.cts",
+        "default": "./dist/internal.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "protobufjs": "^8.0.1",
+    "@korajs/core": "0.1.0",
+    "@korajs/merge": "0.1.0"
+  },
+  "devDependencies": {
+    "@fast-check/vitest": "0.2.0",
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.4"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:chaos": "vitest run tests/integration/chaos-nightly.test.ts",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "clean": "rm -rf dist .turbo coverage"
+  }
+}