@affectively/dash 5.4.1 → 5.4.5

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

@@ -1,1353 +0,0 @@
-import * as Y from 'yjs';
-import { Observable } from 'lib0/observable';
-import * as encoding from 'lib0/encoding';
-import * as decoding from 'lib0/decoding';
-// @ts-ignore
-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';
-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;
-    ws = null;
-    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, 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);
-        }
-        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();
-    }
-    connect() {
-        this.connectWebSocket();
-    }
-    connectWebSocket() {
-        // 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);
-                    });
-                }
-            };
-            this.ws.onmessage = (event) => {
-                this.handleMessage(new Uint8Array(event.data)).catch((err) => {
-                    console.error('[Dash] Failed to handle message:', err);
-                });
-            };
-            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', code: event.code, reason: event.reason }]);
-                // Schedule reconnect with exponential backoff + jitter
-                this.scheduleReconnect();
-            };
-            this.ws.onerror = (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() {
-        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)
-            return;
-        try {
-            // Connect WebTransport
-            // Just an example URL construction, depends on server routing
-            const wtUrl = this.activeRelayUrl + '/sync/' + this.roomName;
-            this.wt = new WebTransport(wtUrl);
-            await this.wt.ready;
-            const stream = await this.wt.createBidirectionalStream();
-            this.writer = stream.writable;
-            this.readLoop(stream.readable);
-            this.highFrequencyMode = true;
-            console.log('Upgraded to WebTransport (High Frequency Mode)');
-        }
-        catch (e) {
-            console.error('Failed to upgrade to WebTransport', e);
-            // Fallback: stay on WebSocket
-        }
-    }
-    sendSyncStep1() {
-        const encoder = encoding.createEncoder();
-        encoding.writeVarUint(encoder, 0); // MessageType.Sync
-        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 = isByob ? readable.getReader({ mode: 'byob' }) : readable.getReader();
-        }
-        catch (e) {
-            reader = readable.getReader();
-        }
-        // 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 (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;
-                        // 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) {
-                    console.log('[Dash] WebTransport stream ended gracefully');
-                    break;
-                }
-                if (result.value) {
-                    this.handleMessage(result.value).catch((err) => {
-                        console.error('[Dash] Failed to process WebTransport message:', err);
-                    });
-                }
-            }
-        }
-        catch (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');
-            }
-        }
-    }
-    /**
-     * 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;
-                }
-                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) {
-            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);
-            }
-        }
-        // 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) {
-        if (origin === this)
-            return;
-        // 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) {
-            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
-        encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.awareness, changedClients));
-        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();
-        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
-    // ============================================
-    /**
-     * Get comprehensive connection status
-     */
-    getConnectionStatus() {
-        let wsState = 'closed';
-        if (this.ws) {
-            switch (this.ws.readyState) {
-                case WebSocket.CONNECTING:
-                    wsState = 'connecting';
-                    break;
-                case WebSocket.OPEN:
-                    wsState = 'open';
-                    break;
-                case WebSocket.CLOSING:
-                    wsState = 'closing';
-                    break;
-                case WebSocket.CLOSED:
-                    wsState = 'closed';
-                    break;
-            }
-        }
-        return {
-            connected: this.connected,
-            connectionState: this.connectionState,
-            roomName: this.roomName,
-            url: this.activeRelayUrl,
-            reconnectAttempts: this.reconnectAttempts,
-            websocket: {
-                state: wsState,
-                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
-     */
-    getAwarenessStates() {
-        const states = [];
-        const awarenessStates = this.awareness.getStates();
-        awarenessStates.forEach((state, clientId) => {
-            states.push({
-                clientId,
-                state,
-                isLocal: clientId === this.awareness.clientID
-            });
-        });
-        return states;
-    }
-    /**
-     * Get the local client ID
-     */
-    getLocalClientId() {
-        return this.awareness.clientID;
-    }
-    /**
-     * Get connected peer count (excluding local)
-     */
-    getPeerCount() {
-        const states = this.awareness.getStates();
-        return Math.max(0, states.size - 1); // Exclude self
-    }
-    /**
-     * Get document state information
-     */
-    getDocumentState() {
-        const stateVector = Y.encodeStateVector(this.doc);
-        const update = Y.encodeStateAsUpdate(this.doc);
-        // Get shared types info
-        const sharedTypes = [];
-        this.doc.share.forEach((type, name) => {
-            let typeKind = 'unknown';
-            let size = 0;
-            if (type instanceof Y.Map) {
-                typeKind = 'YMap';
-                size = type.size;
-            }
-            else if (type instanceof Y.Array) {
-                typeKind = 'YArray';
-                size = type.length;
-            }
-            else if (type instanceof Y.Text) {
-                typeKind = 'YText';
-                size = type.length;
-            }
-            else if (type instanceof Y.XmlFragment) {
-                typeKind = 'YXmlFragment';
-                size = type.length;
-            }
-            sharedTypes.push({
-                name,
-                type: typeKind,
-                size
-            });
-        });
-        return {
-            clientId: this.doc.clientID,
-            guid: this.doc.guid,
-            stateVectorSize: stateVector.byteLength,
-            updateSize: update.byteLength,
-            sharedTypes,
-            transactionCount: 0, // Yjs doesn't expose this directly
-            gcEnabled: this.doc.gc
-        };
-    }
-    /**
-     * Get a snapshot of the Yjs document for inspection
-     */
-    getDocumentSnapshot() {
-        const content = {};
-        this.doc.share.forEach((type, name) => {
-            try {
-                if (type instanceof Y.Map) {
-                    content[name] = type.toJSON();
-                }
-                else if (type instanceof Y.Array) {
-                    content[name] = type.toJSON();
-                }
-                else if (type instanceof Y.Text) {
-                    content[name] = type.toString();
-                }
-                else if (type instanceof Y.XmlFragment) {
-                    content[name] = type.toString();
-                }
-                else {
-                    content[name] = '[unsupported type]';
-                }
-            }
-            catch (e) {
-                content[name] = '[error reading content]';
-            }
-        });
-        return {
-            timestamp: new Date().toISOString(),
-            roomName: this.roomName,
-            content
-        };
-    }
-    /**
-     * Set local awareness state for introspection (admin view)
-     */
-    setLocalAwareness(state) {
-        this.awareness.setLocalState(state);
-    }
-    /**
-     * Get full provider status for debugging
-     */
-    getProviderStatus() {
-        return {
-            connection: this.getConnectionStatus(),
-            awareness: {
-                localClientId: this.awareness.clientID,
-                peerCount: this.getPeerCount(),
-                states: this.getAwarenessStates()
-            },
-            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,
-            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;
-}