@affectively/dash 5.0.1 → 5.1.0

package/dist/src/sync/hybrid-provider.js

@@ -6,6 +6,17 @@ import * as decoding from 'lib0/decoding';
 import * as syncProtocol from 'y-protocols/sync';
 // @ts-ignore
 import * as awarenessProtocol from 'y-protocols/awareness';
+// Aeon integration
+import { defaultAeonConfig } from './aeon/config.js';
+import { DashDeltaAdapter } from './aeon/delta-adapter.js';
+import { DashPresenceAdapter } from './aeon/presence-adapter.js';
+import { DashOfflineAdapter } from './aeon/offline-adapter.js';
+// Message types
+const MessageType = {
+    Sync: 0,
+    Awareness: 1,
+    Delta: 2, // New: Aeon delta-compressed sync
+};
 export class HybridProvider extends Observable {
     doc;
     ws = null;
@@ -17,12 +28,28 @@ export class HybridProvider extends Observable {
     writer = null;
     // "High Frequency" mode uses WebTransport for ephemeral data
     highFrequencyMode = false;
-    constructor(url, roomName, doc, { awareness = new awarenessProtocol.Awareness(doc) } = {}) {
+    // Aeon integration
+    aeonConfig;
+    deltaAdapter = null;
+    presenceAdapter = null;
+    offlineAdapter = null;
+    constructor(url, roomName, doc, { awareness = new awarenessProtocol.Awareness(doc), aeonConfig = defaultAeonConfig, } = {}) {
         super();
         this.url = url;
         this.roomName = roomName;
         this.doc = doc;
         this.awareness = awareness;
+        this.aeonConfig = aeonConfig;
+        // Initialize Aeon adapters
+        if (aeonConfig.enableDeltaSync) {
+            this.deltaAdapter = new DashDeltaAdapter(roomName, aeonConfig.deltaThreshold);
+        }
+        if (aeonConfig.enableRichPresence) {
+            this.presenceAdapter = new DashPresenceAdapter(roomName, awareness);
+        }
+        if (aeonConfig.enableOfflineQueue) {
+            this.offlineAdapter = new DashOfflineAdapter(doc, roomName, aeonConfig.maxOfflineQueueSize, aeonConfig.maxOfflineRetries);
+        }
         this.doc.on('update', this.onDocUpdate.bind(this));
         this.awareness.on('update', this.onAwarenessUpdate.bind(this));
         this.connect();
@@ -140,19 +167,28 @@ export class HybridProvider extends Observable {
         }
     }
     handleMessage(buf) {
-        // Simple protocol: First byte is message type (0=Sync, 1=Awareness)
+        // Simple protocol: First byte is message type (0=Sync, 1=Awareness, 2=Delta)
         // In strict binary mode, we might need a more robust header.
         // For now assuming Y-protocol encoding.
         // Note: The Relay DO sends raw messages back.
         const decoder = decoding.createDecoder(buf);
         const messageType = decoding.readVarUint(decoder);
         switch (messageType) {
-            case 0: // Sync
+            case MessageType.Sync:
                 syncProtocol.readSyncMessage(decoder, encoding.createEncoder(), this.doc, this);
                 break;
-            case 1: // Awareness
+            case MessageType.Awareness:
                 awarenessProtocol.applyAwarenessUpdate(this.awareness, decoding.readVarUint8Array(decoder), this);
                 break;
+            case MessageType.Delta:
+                // Handle Aeon delta-compressed sync
+                if (this.deltaAdapter) {
+                    const deltaPayloadBytes = decoding.readVarUint8Array(decoder);
+                    const deltaPayload = this.deltaAdapter.decodePayload(deltaPayloadBytes);
+                    const update = this.deltaAdapter.unwrapDelta(deltaPayload);
+                    Y.applyUpdate(this.doc, update, this);
+                }
+                break;
         }
     }
     async send(message) {
@@ -170,10 +206,26 @@ export class HybridProvider extends Observable {
     onDocUpdate(update, origin) {
         if (origin === this)
             return;
-        const encoder = encoding.createEncoder();
-        encoding.writeVarUint(encoder, 0); // MessageType.Sync
-        syncProtocol.writeUpdate(encoder, update);
-        this.send(encoding.toUint8Array(encoder));
+        // Check if we should queue (offline)
+        if (this.offlineAdapter?.shouldQueue()) {
+            this.offlineAdapter.queueUpdate(update);
+            return;
+        }
+        // Use delta compression if enabled
+        if (this.deltaAdapter) {
+            const deltaPayload = this.deltaAdapter.wrapUpdate(update, origin);
+            const encoder = encoding.createEncoder();
+            encoding.writeVarUint(encoder, MessageType.Delta);
+            encoding.writeVarUint8Array(encoder, this.deltaAdapter.encodePayload(deltaPayload));
+            this.send(encoding.toUint8Array(encoder));
+        }
+        else {
+            // Standard Yjs sync
+            const encoder = encoding.createEncoder();
+            encoding.writeVarUint(encoder, MessageType.Sync);
+            syncProtocol.writeUpdate(encoder, update);
+            this.send(encoding.toUint8Array(encoder));
+        }
     }
     onAwarenessUpdate({ added, updated, removed }, origin) {
         if (origin === this)
@@ -189,10 +241,61 @@ export class HybridProvider extends Observable {
         this.awareness.off('update', this.onAwarenessUpdate);
         this.ws?.close();
         this.wt?.close();
+        // Cleanup Aeon adapters
+        this.presenceAdapter?.destroy();
+        this.offlineAdapter?.destroy();
         this.connected = false;
         super.destroy();
     }
     // ============================================
+    // AEON ADAPTER ACCESSORS
+    // ============================================
+    /**
+     * Get the delta adapter for compression stats
+     */
+    getDeltaAdapter() {
+        return this.deltaAdapter;
+    }
+    /**
+     * Get the presence adapter for rich presence features
+     */
+    getPresenceAdapter() {
+        return this.presenceAdapter;
+    }
+    /**
+     * Get the offline adapter for queue management
+     */
+    getOfflineAdapter() {
+        return this.offlineAdapter;
+    }
+    /**
+     * Get Aeon configuration
+     */
+    getAeonConfig() {
+        return this.aeonConfig;
+    }
+    /**
+     * Process offline queue when back online
+     */
+    async processOfflineQueue() {
+        if (!this.offlineAdapter) {
+            return { synced: 0, failed: 0 };
+        }
+        return this.offlineAdapter.processQueue(async (update) => {
+            const encoder = encoding.createEncoder();
+            if (this.deltaAdapter) {
+                const deltaPayload = this.deltaAdapter.wrapUpdate(update);
+                encoding.writeVarUint(encoder, MessageType.Delta);
+                encoding.writeVarUint8Array(encoder, this.deltaAdapter.encodePayload(deltaPayload));
+            }
+            else {
+                encoding.writeVarUint(encoder, MessageType.Sync);
+                syncProtocol.writeUpdate(encoder, update);
+            }
+            await this.send(encoding.toUint8Array(encoder));
+        });
+    }
+    // ============================================
     // INTROSPECTION METHODS FOR DASH-STUDIO
     // ============================================
     /**
@@ -352,7 +455,23 @@ export class HybridProvider extends Observable {
                 peerCount: this.getPeerCount(),
                 states: this.getAwarenessStates()
             },
-            document: this.getDocumentState()
+            document: this.getDocumentState(),
+            aeon: this.getAeonStatus()
+        };
+    }
+    /**
+     * Get Aeon-specific status
+     */
+    getAeonStatus() {
+        return {
+            enabled: {
+                deltaSync: this.aeonConfig.enableDeltaSync,
+                richPresence: this.aeonConfig.enableRichPresence,
+                offlineQueue: this.aeonConfig.enableOfflineQueue,
+            },
+            delta: this.deltaAdapter?.getStats() ?? null,
+            offline: this.offlineAdapter?.getStats() ?? null,
+            presence: this.presenceAdapter?.getStats() ?? null,
         };
     }
 }