@affectively/dash 5.3.0 → 5.4.0

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

@@ -11,11 +11,21 @@ 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';
+import { CompressionEngine, AdaptiveCompressionOptimizer, BatchTimingOptimizer, } from '@affectively/aeon';
 // Message types
 const MessageType = {
     Sync: 0,
     Awareness: 1,
     Delta: 2, // New: Aeon delta-compressed sync
+    Compressed: 3,
+    Encrypted: 4,
+    Batch: 5,
+    Capabilities: 6,
+};
+const CapabilityFlag = {
+    Compression: 1,
+    Encryption: 2,
+    Batch: 4,
 };
 export class HybridProvider extends Observable {
     doc;
@@ -23,23 +33,88 @@ export class HybridProvider extends Observable {
     wt = null;
     connected = false;
     url;
+    activeRelayUrl;
     roomName;
     awareness;
     writer = null;
     // "High Frequency" mode uses WebTransport for ephemeral data
     highFrequencyMode = false;
+    // Connection state machine - prevents race conditions
+    connectionState = 'disconnected';
+    // Exponential backoff state
+    reconnectAttempts = 0;
+    maxReconnectDelay = 30000; // 30s max
+    baseReconnectDelay = 1000; // 1s base
+    reconnectTimeout = null;
+    // Relay discovery state
+    relayDiscovery;
+    discoveredRelayUrls = [];
+    relayDiscoveryCursor = 0;
+    lastRelayDiscoveryAt = null;
+    relayHealth = new Map();
+    // Performance pipeline (Aeon optimization)
+    relayPerformance;
+    compressionEngine = null;
+    adaptiveCompression = null;
+    batchTiming = null;
+    outboundQueue = [];
+    outboundQueueBytes = 0;
+    batchFlushTimeout = null;
+    flushingBatch = false;
+    lastCompressionRatio = null;
+    // Privacy pipeline (room-scoped encryption)
+    relayPrivacy;
+    roomCryptoKey = null;
+    roomCryptoKeyReady = null;
+    localCapabilitiesBitmask = 0;
+    peerCapabilities = new Map();
+    protocolVersion = 2;
+    lastCapabilityAdvertisedAt = null;
     // Aeon integration
     aeonConfig;
     deltaAdapter = null;
     presenceAdapter = null;
     offlineAdapter = null;
-    constructor(url, roomName, doc, { awareness = new awarenessProtocol.Awareness(doc), aeonConfig = defaultAeonConfig, } = {}) {
+    constructor(url, roomName, doc, { awareness = new awarenessProtocol.Awareness(doc), aeonConfig = defaultAeonConfig, relayDiscovery = {}, relayPerformance = {}, relayPrivacy = {}, } = {}) {
         super();
         this.url = url;
+        this.activeRelayUrl = url;
         this.roomName = roomName;
         this.doc = doc;
         this.awareness = awareness;
         this.aeonConfig = aeonConfig;
+        this.relayDiscovery = {
+            enabled: false,
+            bootstrapUrls: [],
+            discoveryPath: '/discovery',
+            refreshIntervalMs: 60_000,
+            requestTimeoutMs: 2_500,
+            maxCandidates: 8,
+            dhtQueryEnabled: true,
+            ...relayDiscovery,
+        };
+        this.relayPerformance = {
+            enableAdaptiveCompression: true,
+            enableBatching: true,
+            compressionThresholdBytes: 512,
+            maxBatchDelayMs: 12,
+            maxBatchSizeBytes: 64 * 1024,
+            ...relayPerformance,
+        };
+        this.relayPrivacy = {
+            enabled: false,
+            ...relayPrivacy,
+        };
+        if (this.relayPerformance.enableAdaptiveCompression) {
+            this.compressionEngine = new CompressionEngine('gzip');
+            this.adaptiveCompression = new AdaptiveCompressionOptimizer();
+            this.batchTiming = new BatchTimingOptimizer();
+            this.seedAdaptiveNetworkProfile();
+        }
+        if (this.relayPrivacy.enabled) {
+            this.roomCryptoKeyReady = this.initializeRoomCryptoKey();
+        }
+        this.localCapabilitiesBitmask = this.computeLocalCapabilities();
         // Initialize Aeon adapters
         if (aeonConfig.enableDeltaSync) {
             this.deltaAdapter = new DashDeltaAdapter(roomName, aeonConfig.deltaThreshold);
@@ -58,42 +133,373 @@ export class HybridProvider extends Observable {
         this.connectWebSocket();
     }
     connectWebSocket() {
-        // Protocol: switch http/https to ws/wss
-        // Protocol: switch http/https to ws/wss
-        // 1. Get Token
-        // Ideally await this before connecting, but construction is sync.
-        // We'll make connect async internally or fire-and-forget with token wait.
-        this.getAuthToken().then(token => {
-            const wsUrl = this.url.replace(/^http/, 'ws') + '/sync/' + this.roomName + '?token=' + token;
+        // Guard: prevent multiple simultaneous connection attempts
+        if (this.connectionState === 'connecting' || this.connectionState === 'connected') {
+            return;
+        }
+        this.connectionState = 'connecting';
+        this.emit('status', [{ status: 'connecting' }]);
+        const connectionPromise = Promise.all([
+            this.getAuthToken(),
+            this.resolveRelayUrl(),
+        ]);
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Auth token timeout (10s)')), 10000));
+        Promise.race([connectionPromise, timeoutPromise])
+            .then(result => {
+            if (!result) {
+                throw new Error('Connection setup timed out');
+            }
+            const [token, relayUrl] = result;
+            // Validate token was obtained
+            if (!token) {
+                throw new Error('Auth token is empty or undefined');
+            }
+            // Double-check we weren't destroyed while waiting
+            if (this.connectionState === 'disconnected') {
+                return;
+            }
+            this.activeRelayUrl = relayUrl;
+            this.peerCapabilities.clear();
+            const wsUrl = relayUrl.replace(/^http/, 'ws') + '/sync/' + this.roomName + '?token=' + token;
+            const connectionStartedAt = Date.now();
             this.ws = new WebSocket(wsUrl);
             this.ws.binaryType = 'arraybuffer';
             this.ws.onopen = () => {
+                this.recordRelaySuccess(this.activeRelayUrl, Date.now() - connectionStartedAt);
+                this.connectionState = 'connected';
                 this.connected = true;
+                this.reconnectAttempts = 0; // Reset backoff on successful connection
                 this.emit('status', [{ status: 'connected' }]);
                 this.sendSyncStep1();
+                this.sendCapabilitiesAdvertisement(true).catch((err) => {
+                    console.warn('[Dash] Failed to advertise capabilities:', err);
+                });
+                // Process any queued offline updates
+                if (this.offlineAdapter) {
+                    this.processOfflineQueue().catch(err => {
+                        console.warn('[Dash] Failed to process offline queue:', err);
+                    });
+                }
             };
-            // ... rest of event handlers
             this.ws.onmessage = (event) => {
-                this.handleMessage(new Uint8Array(event.data));
+                this.handleMessage(new Uint8Array(event.data)).catch((err) => {
+                    console.error('[Dash] Failed to handle message:', err);
+                });
             };
-            this.ws.onclose = () => {
+            this.ws.onclose = (event) => {
+                if (event.code !== 1000) {
+                    this.recordRelayFailure(this.activeRelayUrl);
+                }
                 this.connected = false;
+                this.connectionState = 'disconnected';
                 this.ws = null;
-                this.emit('status', [{ status: 'disconnected' }]);
-                // Reconnect logic
-                setTimeout(() => this.connectWebSocket(), 3000);
+                this.emit('status', [{ status: 'disconnected', code: event.code, reason: event.reason }]);
+                // Schedule reconnect with exponential backoff + jitter
+                this.scheduleReconnect();
             };
             this.ws.onerror = (err) => {
-                console.error('WebSocket error', err);
+                this.recordRelayFailure(this.activeRelayUrl);
+                console.error('[Dash] WebSocket error:', err);
+                this.emit('error', [{ type: 'websocket', error: err }]);
+                // Note: onerror is always followed by onclose, so reconnect happens there
             };
+        })
+            .catch(err => {
+            console.error('[Dash] Connection failed:', err.message);
+            this.connectionState = 'disconnected';
+            this.emit('error', [{ type: 'auth', error: err }]);
+            // Schedule reconnect even on auth failure (token might refresh)
+            this.scheduleReconnect();
         });
     }
+    /**
+     * Schedule reconnection with exponential backoff + jitter
+     * Prevents thundering herd on network flapping
+     */
+    scheduleReconnect() {
+        // Clear any existing timeout
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+        }
+        this.reconnectAttempts++;
+        // Exponential backoff: 1s, 2s, 4s, 8s, 16s, 30s (max)
+        const exponentialDelay = Math.min(this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+        // Add jitter: ±25% to prevent thundering herd
+        const jitter = exponentialDelay * 0.25 * (Math.random() * 2 - 1);
+        const delay = Math.round(exponentialDelay + jitter);
+        console.log(`[Dash] Scheduling reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        this.connectionState = 'reconnecting';
+        this.emit('status', [{ status: 'reconnecting', attempt: this.reconnectAttempts, delay }]);
+        this.reconnectTimeout = setTimeout(() => {
+            this.connectionState = 'disconnected'; // Reset for new attempt
+            this.connectWebSocket();
+        }, delay);
+    }
+    seedAdaptiveNetworkProfile() {
+        if (!this.adaptiveCompression || typeof navigator === 'undefined') {
+            return;
+        }
+        const nav = navigator;
+        const downlinkMbps = nav.connection?.downlink ?? 5;
+        const rtt = nav.connection?.rtt ?? 50;
+        this.adaptiveCompression.updateNetworkConditions(Math.round(downlinkMbps * 1000), rtt, true);
+        this.batchTiming?.recordNetworkMeasurement(rtt, downlinkMbps);
+    }
+    async initializeRoomCryptoKey() {
+        if (!this.relayPrivacy.enabled) {
+            this.roomCryptoKey = null;
+            return;
+        }
+        if (typeof crypto === 'undefined' || !crypto.subtle) {
+            console.warn('[Dash] crypto.subtle unavailable; disabling relay privacy');
+            this.relayPrivacy.enabled = false;
+            this.roomCryptoKey = null;
+            this.localCapabilitiesBitmask = this.computeLocalCapabilities();
+            return;
+        }
+        const source = this.relayPrivacy.roomKey;
+        if (!source) {
+            console.warn('[Dash] relayPrivacy.enabled requires roomKey; disabling privacy');
+            this.relayPrivacy.enabled = false;
+            this.roomCryptoKey = null;
+            this.localCapabilitiesBitmask = this.computeLocalCapabilities();
+            return;
+        }
+        const keyBytes = await deriveRoomKeyBytes(source);
+        this.roomCryptoKey = await crypto.subtle.importKey('raw', toArrayBuffer(keyBytes), { name: 'AES-GCM' }, false, ['encrypt', 'decrypt']);
+        this.localCapabilitiesBitmask = this.computeLocalCapabilities();
+    }
+    async getRoomCryptoKey() {
+        if (!this.relayPrivacy.enabled) {
+            return null;
+        }
+        if (this.roomCryptoKey) {
+            return this.roomCryptoKey;
+        }
+        if (!this.roomCryptoKeyReady) {
+            this.roomCryptoKeyReady = this.initializeRoomCryptoKey();
+        }
+        await this.roomCryptoKeyReady;
+        return this.roomCryptoKey;
+    }
+    computeLocalCapabilities() {
+        let bitmask = 0;
+        if (this.relayPerformance.enableAdaptiveCompression) {
+            bitmask |= CapabilityFlag.Compression;
+        }
+        if (this.relayPrivacy.enabled) {
+            bitmask |= CapabilityFlag.Encryption;
+        }
+        if (this.relayPerformance.enableBatching) {
+            bitmask |= CapabilityFlag.Batch;
+        }
+        return bitmask;
+    }
+    getKnownRemoteClientIds() {
+        const ids = [];
+        this.awareness.getStates().forEach((_state, clientId) => {
+            if (clientId !== this.awareness.clientID) {
+                ids.push(clientId);
+            }
+        });
+        return ids;
+    }
+    isCapabilityEnabled(flag) {
+        if ((this.localCapabilitiesBitmask & flag) === 0) {
+            return false;
+        }
+        const remoteIds = this.getKnownRemoteClientIds();
+        if (remoteIds.length === 0) {
+            return false;
+        }
+        return remoteIds.every((clientId) => {
+            const capabilities = this.peerCapabilities.get(clientId) ?? 0;
+            return (capabilities & flag) !== 0;
+        });
+    }
+    capabilityListFromBitmask(bitmask) {
+        const list = [];
+        if ((bitmask & CapabilityFlag.Compression) !== 0)
+            list.push('compression');
+        if ((bitmask & CapabilityFlag.Encryption) !== 0)
+            list.push('encryption');
+        if ((bitmask & CapabilityFlag.Batch) !== 0)
+            list.push('batch');
+        return list;
+    }
+    async sendCapabilitiesAdvertisement(force = false) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        const now = Date.now();
+        if (!force && this.lastCapabilityAdvertisedAt && now - this.lastCapabilityAdvertisedAt < 5_000) {
+            return;
+        }
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, MessageType.Capabilities);
+        encoding.writeVarUint(encoder, this.protocolVersion);
+        encoding.writeVarUint(encoder, this.awareness.clientID);
+        encoding.writeVarUint(encoder, this.localCapabilitiesBitmask);
+        const payload = encoding.toUint8Array(encoder);
+        await this.sendSingleFrame(payload, []);
+        this.lastCapabilityAdvertisedAt = now;
+    }
+    reconcilePeerCapabilities(removed = []) {
+        for (const clientId of removed) {
+            this.peerCapabilities.delete(clientId);
+        }
+        const livePeers = new Set(this.getKnownRemoteClientIds());
+        for (const clientId of this.peerCapabilities.keys()) {
+            if (!livePeers.has(clientId)) {
+                this.peerCapabilities.delete(clientId);
+            }
+        }
+    }
     async getAuthToken() {
-        // Lazy load auth to avoid circular dependency issues if any
-        const { auth } = await import('../auth/manager.js');
-        // For MVP, we assume the Relay allows any DID to connect if they sign it.
-        // In prod, you'd know the Relay's DID.
-        return auth.issueRoomToken("did:web:relay.buley.dev", this.roomName);
+        try {
+            // Lazy load auth to avoid circular dependency issues if any
+            const { auth } = await import('../auth/manager.js');
+            // For MVP, we assume the Relay allows any DID to connect if they sign it.
+            // In prod, you'd know the Relay's DID.
+            const token = await auth.issueRoomToken("did:web:relay.buley.dev", this.roomName);
+            return token || 'dash-anonymous-token';
+        }
+        catch {
+            // Graceful fallback for environments that don't initialize auth yet.
+            return 'dash-anonymous-token';
+        }
+    }
+    async resolveRelayUrl() {
+        if (!this.relayDiscovery.enabled) {
+            return this.activeRelayUrl;
+        }
+        const refreshMs = this.relayDiscovery.refreshIntervalMs ?? 60_000;
+        const shouldRefresh = this.discoveredRelayUrls.length === 0 ||
+            this.lastRelayDiscoveryAt === null ||
+            Date.now() - this.lastRelayDiscoveryAt > refreshMs;
+        if (shouldRefresh) {
+            this.discoveredRelayUrls = await this.discoverRelayUrls();
+            this.relayDiscoveryCursor = 0;
+            this.lastRelayDiscoveryAt = Date.now();
+        }
+        if (this.discoveredRelayUrls.length === 0) {
+            return this.activeRelayUrl;
+        }
+        const rankedRelays = this.rankRelayUrls(this.discoveredRelayUrls);
+        const idx = this.relayDiscoveryCursor % rankedRelays.length;
+        this.relayDiscoveryCursor += 1;
+        return rankedRelays[idx];
+    }
+    async discoverRelayUrls() {
+        const seedUrls = [
+            this.activeRelayUrl,
+            ...(this.relayDiscovery.bootstrapUrls ?? []),
+        ];
+        const uniqueSeeds = dedupeRelayUrls(seedUrls);
+        const discoveryPath = (this.relayDiscovery.discoveryPath || '/discovery').replace(/\/+$/, '');
+        const targetPeerId = normalizePeerId(this.relayDiscovery.targetPeerId || this.roomName);
+        const discoveryRequests = uniqueSeeds.flatMap(seed => {
+            const requests = [
+                this.fetchRelayCandidates(`${seed}${discoveryPath}/bootstrap`),
+            ];
+            if (this.relayDiscovery.dhtQueryEnabled !== false) {
+                requests.push(this.fetchRelayCandidates(`${seed}${discoveryPath}/peers?target=${encodeURIComponent(targetPeerId)}&k=${this.relayDiscovery.maxCandidates ?? 8}`));
+            }
+            return requests;
+        });
+        const results = await Promise.allSettled(discoveryRequests);
+        const discovered = [this.activeRelayUrl];
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                discovered.push(...result.value);
+            }
+        }
+        return dedupeRelayUrls(discovered).slice(0, this.relayDiscovery.maxCandidates ?? 8);
+    }
+    async fetchRelayCandidates(url) {
+        const timeoutMs = this.relayDiscovery.requestTimeoutMs ?? 2_500;
+        const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+        const timeout = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
+        const startedAt = Date.now();
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                signal: controller?.signal,
+            });
+            if (!response.ok) {
+                const seedRelay = getRelayOriginFromDiscoveryUrl(url);
+                if (seedRelay)
+                    this.recordRelayFailure(seedRelay);
+                return [];
+            }
+            const payload = await response.json();
+            const seedRelay = getRelayOriginFromDiscoveryUrl(url);
+            if (seedRelay) {
+                this.recordRelaySuccess(seedRelay, Date.now() - startedAt);
+            }
+            return extractRelayUrls(payload);
+        }
+        catch {
+            const seedRelay = getRelayOriginFromDiscoveryUrl(url);
+            if (seedRelay)
+                this.recordRelayFailure(seedRelay);
+            return [];
+        }
+        finally {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        }
+    }
+    rankRelayUrls(relays) {
+        return [...relays].sort((left, right) => this.scoreRelay(left) - this.scoreRelay(right));
+    }
+    scoreRelay(relayUrl) {
+        const health = this.relayHealth.get(relayUrl);
+        if (!health) {
+            return 500;
+        }
+        const failurePenalty = health.failures * 250;
+        const successBonus = Math.min(100, health.successes * 10);
+        return health.avgLatencyMs + failurePenalty - successBonus;
+    }
+    recordRelaySuccess(relayUrl, latencyMs) {
+        const current = this.relayHealth.get(relayUrl);
+        if (!current) {
+            this.relayHealth.set(relayUrl, {
+                successes: 1,
+                failures: 0,
+                avgLatencyMs: Math.max(1, latencyMs),
+                lastUpdatedAt: Date.now(),
+            });
+            return;
+        }
+        const nextSuccesses = current.successes + 1;
+        const nextAvg = Math.round((current.avgLatencyMs * current.successes + latencyMs) / nextSuccesses);
+        this.relayHealth.set(relayUrl, {
+            successes: nextSuccesses,
+            failures: current.failures,
+            avgLatencyMs: Math.max(1, nextAvg),
+            lastUpdatedAt: Date.now(),
+        });
+    }
+    recordRelayFailure(relayUrl) {
+        const current = this.relayHealth.get(relayUrl);
+        if (!current) {
+            this.relayHealth.set(relayUrl, {
+                successes: 0,
+                failures: 1,
+                avgLatencyMs: 800,
+                lastUpdatedAt: Date.now(),
+            });
+            return;
+        }
+        this.relayHealth.set(relayUrl, {
+            ...current,
+            failures: current.failures + 1,
+            avgLatencyMs: Math.min(5_000, current.avgLatencyMs + 100),
+            lastUpdatedAt: Date.now(),
+        });
     }
     async enterHighFrequencyMode() {
         if (this.highFrequencyMode)
@@ -101,7 +507,7 @@ export class HybridProvider extends Observable {
         try {
             // Connect WebTransport
             // Just an example URL construction, depends on server routing
-            const wtUrl = this.url + '/sync/' + this.roomName;
+            const wtUrl = this.activeRelayUrl + '/sync/' + this.roomName;
             this.wt = new WebTransport(wtUrl);
             await this.wt.ready;
             const stream = await this.wt.createBidirectionalStream();
@@ -121,86 +527,389 @@ export class HybridProvider extends Observable {
         syncProtocol.writeSyncStep1(encoder, this.doc);
         this.send(encoding.toUint8Array(encoder));
     }
+    /**
+     * Read loop for WebTransport with dynamic buffer sizing
+     * Handles payloads larger than initial buffer
+     */
     async readLoop(readable) {
         let reader;
+        const isByob = typeof ReadableStreamBYOBReader !== 'undefined';
         try {
             // @ts-ignore
-            reader = readable.getReader({ mode: 'byob' });
+            reader = isByob ? readable.getReader({ mode: 'byob' }) : readable.getReader();
         }
         catch (e) {
             reader = readable.getReader();
         }
-        // Pre-allocate buffer (64KB) to emulate Zero-Copy / WASM Heap view
-        // In a future update, this could be a view into `sqlite3.wasm.memory`.
-        let buffer = new Uint8Array(65536);
+        // Start with 64KB, grow dynamically if needed (max 16MB)
+        const MIN_BUFFER_SIZE = 65536; // 64KB
+        const MAX_BUFFER_SIZE = 16777216; // 16MB
+        let bufferSize = MIN_BUFFER_SIZE;
+        let buffer = new Uint8Array(bufferSize);
+        let consecutiveLargeReads = 0;
         try {
             while (true) {
                 let result;
-                if (reader.readAtLeast) {
-                    // BYOB Reader
-                    // We pass the view. The reader detaches it and returns a new view (potentially same backing store).
+                if (isByob && reader.read.length > 0) {
+                    // BYOB Reader - pre-allocate buffer
                     result = await reader.read(new Uint8Array(buffer.buffer, 0, buffer.byteLength));
                     if (result.value) {
-                        buffer = result.value; // Update our reference to the valid buffer
+                        buffer = result.value;
+                        // Dynamic buffer growth: if we're consistently filling the buffer, grow it
+                        if (result.value.byteLength >= bufferSize * 0.9) {
+                            consecutiveLargeReads++;
+                            if (consecutiveLargeReads >= 3 && bufferSize < MAX_BUFFER_SIZE) {
+                                bufferSize = Math.min(bufferSize * 2, MAX_BUFFER_SIZE);
+                                buffer = new Uint8Array(bufferSize);
+                                console.log(`[Dash] Grew WebTransport buffer to ${bufferSize / 1024}KB`);
+                            }
+                        }
+                        else {
+                            consecutiveLargeReads = 0;
+                        }
                     }
                 }
                 else {
                     // Default Reader
                     result = await reader.read();
                 }
-                if (result.done)
+                if (result.done) {
+                    console.log('[Dash] WebTransport stream ended gracefully');
                     break;
+                }
                 if (result.value) {
-                    // Processing: In true zero-copy, we'd pass the offset/length to SQL directly.
-                    // Here we pass the view.
-                    this.handleMessage(result.value);
+                    this.handleMessage(result.value).catch((err) => {
+                        console.error('[Dash] Failed to process WebTransport message:', err);
+                    });
                 }
             }
         }
         catch (e) {
-            console.error('WebTransport Read loop error', e);
+            // Check if this is a recoverable error
+            const errorMessage = e.message || '';
+            if (errorMessage.includes('aborted') || errorMessage.includes('closed')) {
+                console.log('[Dash] WebTransport connection closed');
+            }
+            else {
+                console.error('[Dash] WebTransport read loop error:', e);
+                this.emit('error', [{ type: 'webtransport', error: e }]);
+            }
         }
         finally {
             this.highFrequencyMode = false;
             this.writer = null;
             this.wt = null;
+            // If we were in high-frequency mode and it failed, fall back to WebSocket
+            if (this.connectionState === 'connected') {
+                console.log('[Dash] WebTransport closed, continuing with WebSocket');
+            }
         }
     }
-    handleMessage(buf) {
-        // 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 MessageType.Sync:
-                syncProtocol.readSyncMessage(decoder, encoding.createEncoder(), this.doc, this);
-                break;
-            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);
+    /**
+     * Handle incoming message with protocol validation
+     * Never silently ignores malformed messages
+     */
+    async handleMessage(buf) {
+        // Validate minimum message size
+        if (buf.byteLength < 1) {
+            console.warn('[Dash] Received empty message, ignoring');
+            return;
+        }
+        try {
+            const decoder = decoding.createDecoder(buf);
+            // Check if we can read the message type (decoder has remaining bytes)
+            if (decoder.pos >= decoder.arr.length) {
+                console.warn('[Dash] Message too short to decode type');
+                return;
+            }
+            const messageType = decoding.readVarUint(decoder);
+            switch (messageType) {
+                case MessageType.Sync:
+                    syncProtocol.readSyncMessage(decoder, encoding.createEncoder(), this.doc, this);
+                    break;
+                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);
+                    }
+                    else {
+                        console.warn('[Dash] Received Delta message but delta adapter not enabled');
+                    }
+                    break;
+                case MessageType.Compressed: {
+                    const algorithmCode = decoding.readVarUint(decoder);
+                    const compressedPayload = decoding.readVarUint8Array(decoder);
+                    const decompressed = await this.decompressPayload(compressedPayload, algorithmCode === 1 ? 'gzip' : algorithmCode === 2 ? 'deflate' : 'none');
+                    await this.handleMessage(decompressed);
+                    break;
                 }
-                break;
+                case MessageType.Encrypted: {
+                    const iv = decoding.readVarUint8Array(decoder);
+                    const ciphertext = decoding.readVarUint8Array(decoder);
+                    const plaintext = await this.decryptPayload(iv, ciphertext);
+                    if (plaintext) {
+                        await this.handleMessage(plaintext);
+                    }
+                    break;
+                }
+                case MessageType.Batch: {
+                    const count = decoding.readVarUint(decoder);
+                    for (let i = 0; i < count; i++) {
+                        const frame = decoding.readVarUint8Array(decoder);
+                        await this.handleMessage(frame);
+                    }
+                    break;
+                }
+                case MessageType.Capabilities: {
+                    const remoteProtocolVersion = decoding.readVarUint(decoder);
+                    const remoteClientId = decoding.readVarUint(decoder);
+                    const remoteCapabilities = decoding.readVarUint(decoder);
+                    this.peerCapabilities.set(remoteClientId, remoteCapabilities);
+                    this.emit('status', [{
+                            status: 'capabilities',
+                            protocolVersion: remoteProtocolVersion,
+                            clientId: remoteClientId,
+                            capabilities: this.capabilityListFromBitmask(remoteCapabilities),
+                        }]);
+                    break;
+                }
+                default:
+                    // CRITICAL: Don't silently ignore unknown message types
+                    console.warn(`[Dash] Unknown message type: ${messageType}. Protocol mismatch possible.`);
+                    this.emit('error', [{
+                            type: 'protocol',
+                            error: new Error(`Unknown message type: ${messageType}`),
+                            messageType
+                        }]);
+                    break;
+            }
+        }
+        catch (err) {
+            // Don't let malformed messages crash the sync loop
+            console.error('[Dash] Failed to decode message:', err);
+            this.emit('error', [{
+                    type: 'decode',
+                    error: err,
+                    bufferSize: buf.byteLength
+                }]);
         }
     }
+    /**
+     * Send message with error handling and offline queue fallback
+     * Never fails silently - either sends, queues, or throws
+     */
     async send(message) {
+        if (this.isCapabilityEnabled(CapabilityFlag.Batch)) {
+            this.enqueueOutbound(message);
+            return;
+        }
+        const processed = await this.applyOutboundPipeline(message);
+        await this.sendSingleFrame(processed, [message]);
+    }
+    enqueueOutbound(message) {
+        this.outboundQueue.push(message);
+        this.outboundQueueBytes += message.byteLength;
+        if (this.outboundQueueBytes >= (this.relayPerformance.maxBatchSizeBytes ?? 64 * 1024)) {
+            this.flushOutboundQueue().catch((err) => {
+                console.warn('[Dash] Failed to flush outbound queue:', err);
+            });
+            return;
+        }
+        this.scheduleBatchFlush();
+    }
+    scheduleBatchFlush() {
+        if (this.batchFlushTimeout || this.flushingBatch) {
+            return;
+        }
+        const maxDelay = this.relayPerformance.maxBatchDelayMs ?? 12;
+        const decision = this.batchTiming?.getSchedulingDecision(this.outboundQueueBytes, 'normal', false);
+        const delay = Math.max(0, Math.min(maxDelay, decision?.recommendedDelay ?? maxDelay));
+        this.batchFlushTimeout = setTimeout(() => {
+            this.batchFlushTimeout = null;
+            this.flushOutboundQueue().catch((err) => {
+                console.warn('[Dash] Failed to flush outbound queue:', err);
+            });
+        }, delay);
+    }
+    async flushOutboundQueue() {
+        if (this.flushingBatch || this.outboundQueue.length === 0) {
+            return;
+        }
+        this.flushingBatch = true;
+        try {
+            const batch = this.outboundQueue.splice(0, this.outboundQueue.length);
+            this.outboundQueueBytes = 0;
+            const frame = batch.length === 1 ? batch[0] : this.encodeBatchFrame(batch);
+            const processed = await this.applyOutboundPipeline(frame);
+            await this.sendSingleFrame(processed, batch);
+        }
+        finally {
+            this.flushingBatch = false;
+        }
+    }
+    encodeBatchFrame(messages) {
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, MessageType.Batch);
+        encoding.writeVarUint(encoder, messages.length);
+        for (const message of messages) {
+            encoding.writeVarUint8Array(encoder, message);
+        }
+        return encoding.toUint8Array(encoder);
+    }
+    async applyOutboundPipeline(message) {
+        let payload = message;
+        payload = await this.maybeCompressPayload(payload);
+        payload = await this.maybeEncryptPayload(payload);
+        return payload;
+    }
+    async maybeCompressPayload(message) {
+        if (!this.compressionEngine ||
+            !this.relayPerformance.enableAdaptiveCompression ||
+            !this.isCapabilityEnabled(CapabilityFlag.Compression)) {
+            return message;
+        }
+        if (message.byteLength < (this.relayPerformance.compressionThresholdBytes ?? 512)) {
+            return message;
+        }
+        const recommendation = this.adaptiveCompression?.getRecommendedLevel();
+        if (recommendation && recommendation.recommendedLevel <= 3) {
+            return message;
+        }
+        const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+        const compressed = await this.compressionEngine.compress(message);
+        const elapsed = (typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt;
+        this.adaptiveCompression?.recordCompressionPerformance(recommendation?.recommendedLevel ?? 6, elapsed, compressed.compressionRatio);
+        this.adaptiveCompression?.applyRecommendation();
+        this.lastCompressionRatio = compressed.compressionRatio;
+        if (compressed.algorithm === 'none') {
+            return message;
+        }
+        // Keep payload uncompressed if ratio is poor.
+        if (compressed.compressedSize >= message.byteLength * 0.97) {
+            return message;
+        }
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, MessageType.Compressed);
+        encoding.writeVarUint(encoder, compressed.algorithm === 'gzip' ? 1 : 2);
+        encoding.writeVarUint8Array(encoder, compressed.compressed);
+        return encoding.toUint8Array(encoder);
+    }
+    async decompressPayload(compressedPayload, algorithm) {
+        if (!this.compressionEngine || algorithm === 'none') {
+            return compressedPayload;
+        }
+        return this.compressionEngine.decompress({
+            id: `incoming-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+            compressed: compressedPayload,
+            originalSize: compressedPayload.byteLength,
+            compressedSize: compressedPayload.byteLength,
+            compressionRatio: 0,
+            algorithm,
+            timestamp: Date.now(),
+        });
+    }
+    async maybeEncryptPayload(message) {
+        if (!this.relayPrivacy.enabled || !this.isCapabilityEnabled(CapabilityFlag.Encryption)) {
+            return message;
+        }
+        const key = await this.getRoomCryptoKey();
+        if (!key) {
+            return message;
+        }
+        if (typeof crypto === 'undefined' || !crypto.subtle) {
+            return message;
+        }
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const encrypted = await crypto.subtle.encrypt({ name: 'AES-GCM', iv: toArrayBuffer(iv) }, key, toArrayBuffer(message));
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, MessageType.Encrypted);
+        encoding.writeVarUint8Array(encoder, iv);
+        encoding.writeVarUint8Array(encoder, new Uint8Array(encrypted));
+        return encoding.toUint8Array(encoder);
+    }
+    async decryptPayload(iv, ciphertext) {
+        const key = await this.getRoomCryptoKey();
+        if (!key) {
+            console.warn('[Dash] Received encrypted payload but no room key is configured');
+            return null;
+        }
+        if (typeof crypto === 'undefined' || !crypto.subtle) {
+            return null;
+        }
+        try {
+            const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: toArrayBuffer(iv) }, key, toArrayBuffer(ciphertext));
+            return new Uint8Array(decrypted);
+        }
+        catch (err) {
+            this.emit('error', [{ type: 'privacy', error: err }]);
+            console.warn('[Dash] Failed to decrypt relay payload:', err);
+            return null;
+        }
+    }
+    async sendSingleFrame(payload, originalMessages) {
+        // Try WebTransport first (high frequency mode)
         if (this.writer && this.highFrequencyMode) {
-            // High Priority -> WebTransport
-            const writer = this.writer.getWriter();
-            await writer.write(message);
-            writer.releaseLock();
+            try {
+                const writer = this.writer.getWriter();
+                await writer.write(payload);
+                writer.releaseLock();
+                return;
+            }
+            catch (err) {
+                console.warn('[Dash] WebTransport send failed, falling back to WebSocket:', err);
+            }
         }
-        else if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            // Default -> WebSocket
-            this.ws.send(message);
+        // Try WebSocket
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            try {
+                if (this.ws.bufferedAmount > 1024 * 1024) {
+                    console.warn('[Dash] WebSocket buffer full, queueing message');
+                    for (const message of originalMessages) {
+                        this.queueForOffline(message);
+                    }
+                    return;
+                }
+                this.ws.send(payload);
+                return;
+            }
+            catch (err) {
+                console.warn('[Dash] WebSocket send failed:', err);
+            }
+        }
+        // Neither transport available - queue for later
+        for (const message of originalMessages) {
+            this.queueForOffline(message);
+        }
+    }
+    /**
+     * Queue message for offline sync
+     */
+    queueForOffline(message) {
+        if (this.offlineAdapter) {
+            // Extract the update from the message for proper queuing
+            // The message includes protocol header, but offline adapter expects raw update
+            try {
+                const decoder = decoding.createDecoder(message);
+                const messageType = decoding.readVarUint(decoder);
+                if (messageType === MessageType.Sync || messageType === MessageType.Delta) {
+                    const updateBytes = decoding.readVarUint8Array(decoder);
+                    this.offlineAdapter.queueUpdate(updateBytes);
+                    console.log('[Dash] Message queued for offline sync');
+                }
+            }
+            catch (err) {
+                console.error('[Dash] Failed to queue message:', err);
+            }
+        }
+        else {
+            console.warn('[Dash] Message dropped - no transport and no offline queue');
+            this.emit('error', [{ type: 'send', error: new Error('No transport available and offline queue disabled') }]);
         }
     }
     onDocUpdate(update, origin) {
@@ -228,8 +937,15 @@ export class HybridProvider extends Observable {
         }
     }
     onAwarenessUpdate({ added, updated, removed }, origin) {
-        if (origin === this)
+        if (origin === this) {
+            this.reconcilePeerCapabilities(removed);
+            if (Array.isArray(added) && added.length > 0) {
+                this.sendCapabilitiesAdvertisement(false).catch((err) => {
+                    console.warn('[Dash] Failed to re-advertise capabilities:', err);
+                });
+            }
             return;
+        }
         const changedClients = added.concat(updated).concat(removed);
         const encoder = encoding.createEncoder();
         encoding.writeVarUint(encoder, 1); // MessageType.Awareness
@@ -237,6 +953,20 @@ export class HybridProvider extends Observable {
         this.send(encoding.toUint8Array(encoder));
     }
     destroy() {
+        // Cancel any pending reconnect
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        if (this.batchFlushTimeout) {
+            clearTimeout(this.batchFlushTimeout);
+            this.batchFlushTimeout = null;
+        }
+        this.outboundQueue = [];
+        this.outboundQueueBytes = 0;
+        this.peerCapabilities.clear();
+        // Mark as disconnected to prevent reconnect attempts
+        this.connectionState = 'disconnected';
         this.doc.off('update', this.onDocUpdate);
         this.awareness.off('update', this.onAwarenessUpdate);
         this.ws?.close();
@@ -321,19 +1051,66 @@ export class HybridProvider extends Observable {
         }
         return {
             connected: this.connected,
+            connectionState: this.connectionState,
             roomName: this.roomName,
-            url: this.url,
+            url: this.activeRelayUrl,
+            reconnectAttempts: this.reconnectAttempts,
             websocket: {
                 state: wsState,
-                connected: this.ws !== null && this.ws.readyState === WebSocket.OPEN
+                connected: this.ws !== null && this.ws.readyState === WebSocket.OPEN,
+                bufferedAmount: this.ws?.bufferedAmount ?? 0
             },
             webTransport: {
                 connected: this.wt !== null,
                 highFrequencyMode: this.highFrequencyMode
             },
+            discovery: {
+                enabled: this.relayDiscovery.enabled === true,
+                knownRelays: this.discoveredRelayUrls.length,
+                lastDiscoveryAt: this.lastRelayDiscoveryAt,
+                targetPeerId: normalizePeerId(this.relayDiscovery.targetPeerId || this.roomName),
+            },
+            performance: {
+                batching: this.relayPerformance.enableBatching === true,
+                adaptiveCompression: this.relayPerformance.enableAdaptiveCompression === true,
+                activeBatching: this.isCapabilityEnabled(CapabilityFlag.Batch),
+                activeCompression: this.isCapabilityEnabled(CapabilityFlag.Compression),
+                queuedFrames: this.outboundQueue.length,
+                lastCompressionRatio: this.lastCompressionRatio,
+            },
+            privacy: {
+                enabled: this.relayPrivacy.enabled === true,
+                keyLoaded: this.roomCryptoKey !== null,
+                activeEncryption: this.isCapabilityEnabled(CapabilityFlag.Encryption),
+            },
+            protocol: {
+                version: this.protocolVersion,
+                localCapabilities: this.capabilityListFromBitmask(this.localCapabilitiesBitmask),
+                knownPeers: this.peerCapabilities.size,
+            },
             transport: this.highFrequencyMode ? 'WebTransport' : 'WebSocket'
         };
     }
+    /**
+     * Force immediate reconnection (resets backoff)
+     * Use when user explicitly requests reconnect
+     */
+    forceReconnect() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        // Close existing connections
+        this.ws?.close();
+        this.wt?.close();
+        this.ws = null;
+        this.wt = null;
+        // Reset backoff
+        this.reconnectAttempts = 0;
+        this.connectionState = 'disconnected';
+        // Connect immediately
+        this.connectWebSocket();
+    }
     /**
      * Get all awareness states from connected peers
      */
@@ -472,6 +1249,105 @@ export class HybridProvider extends Observable {
             delta: this.deltaAdapter?.getStats() ?? null,
             offline: this.offlineAdapter?.getStats() ?? null,
             presence: this.presenceAdapter?.getStats() ?? null,
+            compression: this.adaptiveCompression?.getStats() ?? null,
         };
     }
 }
+function normalizePeerId(value) {
+    const trimmed = value.trim().toLowerCase();
+    if (/^[0-9a-f]+$/i.test(trimmed)) {
+        return trimmed;
+    }
+    let hash = 2166136261;
+    for (let i = 0; i < trimmed.length; i++) {
+        hash ^= trimmed.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+function normalizeRelayUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            return null;
+        }
+        return parsed.origin;
+    }
+    catch {
+        return null;
+    }
+}
+function dedupeRelayUrls(urls) {
+    const deduped = new Set();
+    for (const url of urls) {
+        const normalized = normalizeRelayUrl(url);
+        if (normalized)
+            deduped.add(normalized);
+    }
+    return Array.from(deduped);
+}
+function extractRelayUrls(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return [];
+    }
+    const data = payload;
+    const urls = [];
+    const collect = (value) => {
+        if (typeof value === 'string') {
+            urls.push(value);
+            return;
+        }
+        if (!value || typeof value !== 'object') {
+            return;
+        }
+        const record = value;
+        if (typeof record.relayUrl === 'string') {
+            urls.push(record.relayUrl);
+        }
+        else if (typeof record.url === 'string') {
+            urls.push(record.url);
+        }
+    };
+    const candidates = ['bootstrapRelays', 'relays', 'peers'];
+    for (const key of candidates) {
+        const value = data[key];
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                collect(item);
+            }
+        }
+    }
+    return dedupeRelayUrls(urls);
+}
+function getRelayOriginFromDiscoveryUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return `${parsed.protocol}//${parsed.host}`;
+    }
+    catch {
+        return null;
+    }
+}
+async function deriveRoomKeyBytes(input) {
+    if (input instanceof Uint8Array) {
+        if (input.byteLength === 32) {
+            return input;
+        }
+        if (typeof crypto !== 'undefined' && crypto.subtle) {
+            const digest = await crypto.subtle.digest('SHA-256', toArrayBuffer(input));
+            return new Uint8Array(digest);
+        }
+        return input;
+    }
+    const encoded = new TextEncoder().encode(input);
+    if (typeof crypto !== 'undefined' && crypto.subtle) {
+        const digest = await crypto.subtle.digest('SHA-256', toArrayBuffer(encoded));
+        return new Uint8Array(digest);
+    }
+    return encoded;
+}
+function toArrayBuffer(data) {
+    const clone = new Uint8Array(data.byteLength);
+    clone.set(data);
+    return clone.buffer;
+}