@affectively/dash 5.2.1 → 5.3.1

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

@@ -1,477 +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';
-// Message types
-const MessageType = {
-    Sync: 0,
-    Awareness: 1,
-    Delta: 2, // New: Aeon delta-compressed sync
-};
-export class HybridProvider extends Observable {
-    doc;
-    ws = null;
-    wt = null;
-    connected = false;
-    url;
-    roomName;
-    awareness;
-    writer = null;
-    // "High Frequency" mode uses WebTransport for ephemeral data
-    highFrequencyMode = false;
-    // Aeon integration
-    aeonConfig;
-    deltaAdapter = null;
-    presenceAdapter = null;
-    offlineAdapter = null;
-    constructor(url, roomName, doc, { awareness = new awarenessProtocol.Awareness(doc), aeonConfig = defaultAeonConfig, } = {}) {
-        super();
-        this.url = url;
-        this.roomName = roomName;
-        this.doc = doc;
-        this.awareness = awareness;
-        this.aeonConfig = aeonConfig;
-        // Initialize Aeon adapters
-        if (aeonConfig.enableDeltaSync) {
-            this.deltaAdapter = new DashDeltaAdapter(roomName, aeonConfig.deltaThreshold);
-        }
-        if (aeonConfig.enableRichPresence) {
-            this.presenceAdapter = new DashPresenceAdapter(roomName, awareness);
-        }
-        if (aeonConfig.enableOfflineQueue) {
-            this.offlineAdapter = new DashOfflineAdapter(doc, roomName, aeonConfig.maxOfflineQueueSize, aeonConfig.maxOfflineRetries);
-        }
-        this.doc.on('update', this.onDocUpdate.bind(this));
-        this.awareness.on('update', this.onAwarenessUpdate.bind(this));
-        this.connect();
-    }
-    connect() {
-        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;
-            this.ws = new WebSocket(wsUrl);
-            this.ws.binaryType = 'arraybuffer';
-            this.ws.onopen = () => {
-                this.connected = true;
-                this.emit('status', [{ status: 'connected' }]);
-                this.sendSyncStep1();
-            };
-            // ... rest of event handlers
-            this.ws.onmessage = (event) => {
-                this.handleMessage(new Uint8Array(event.data));
-            };
-            this.ws.onclose = () => {
-                this.connected = false;
-                this.ws = null;
-                this.emit('status', [{ status: 'disconnected' }]);
-                // Reconnect logic
-                setTimeout(() => this.connectWebSocket(), 3000);
-            };
-            this.ws.onerror = (err) => {
-                console.error('WebSocket error', err);
-            };
-        });
-    }
-    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);
-    }
-    async enterHighFrequencyMode() {
-        if (this.highFrequencyMode)
-            return;
-        try {
-            // Connect WebTransport
-            // Just an example URL construction, depends on server routing
-            const wtUrl = this.url + '/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));
-    }
-    async readLoop(readable) {
-        let reader;
-        try {
-            // @ts-ignore
-            reader = readable.getReader({ mode: 'byob' });
-        }
-        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);
-        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).
-                    result = await reader.read(new Uint8Array(buffer.buffer, 0, buffer.byteLength));
-                    if (result.value) {
-                        buffer = result.value; // Update our reference to the valid buffer
-                    }
-                }
-                else {
-                    // Default Reader
-                    result = await reader.read();
-                }
-                if (result.done)
-                    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);
-                }
-            }
-        }
-        catch (e) {
-            console.error('WebTransport Read loop error', e);
-        }
-        finally {
-            this.highFrequencyMode = false;
-            this.writer = null;
-            this.wt = null;
-        }
-    }
-    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);
-                }
-                break;
-        }
-    }
-    async send(message) {
-        if (this.writer && this.highFrequencyMode) {
-            // High Priority -> WebTransport
-            const writer = this.writer.getWriter();
-            await writer.write(message);
-            writer.releaseLock();
-        }
-        else if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            // Default -> WebSocket
-            this.ws.send(message);
-        }
-    }
-    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)
-            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() {
-        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,
-            roomName: this.roomName,
-            url: this.url,
-            websocket: {
-                state: wsState,
-                connected: this.ws !== null && this.ws.readyState === WebSocket.OPEN
-            },
-            webTransport: {
-                connected: this.wt !== null,
-                highFrequencyMode: this.highFrequencyMode
-            },
-            transport: this.highFrequencyMode ? 'WebTransport' : 'WebSocket'
-        };
-    }
-    /**
-     * 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,
-        };
-    }
-}

package/dist/src/sync/provider.d.ts

@@ -1,11 +0,0 @@
-import * as Y from 'yjs';
-export declare class YjsSqliteProvider {
-    private doc;
-    private roomName;
-    whenSynced: Promise<void>;
-    constructor(roomName: string, doc: Y.Doc);
-    private persistUpdate;
-    private loadState;
-    private toBase64;
-    private fromBase64;
-}

package/dist/src/sync/provider.js

@@ -1,67 +0,0 @@
-import * as Y from 'yjs';
-import { dash } from '../engine/sqlite.js';
-export class YjsSqliteProvider {
-    doc;
-    roomName;
-    whenSynced;
-    constructor(roomName, doc) {
-        this.roomName = roomName;
-        this.doc = doc;
-        // Listen to local updates
-        doc.on('update', (update, origin) => {
-            if (origin !== this) {
-                this.persistUpdate(update);
-            }
-        });
-        // Load initial state
-        this.whenSynced = this.loadState();
-    }
-    async persistUpdate(update) {
-        await dash.ready();
-        const blob = this.toBase64(update);
-        dash.execute('INSERT INTO dash_sync_updates (room, update_blob) VALUES (?, ?)', [this.roomName, blob]);
-    }
-    async loadState() {
-        await dash.ready();
-        // Ensure sync table exists
-        dash.execute(`
-        CREATE TABLE IF NOT EXISTS dash_sync_updates (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            room TEXT,
-            update_blob TEXT,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-      `);
-        const rows = dash.execute('SELECT update_blob FROM dash_sync_updates WHERE room = ? ORDER BY id ASC', [this.roomName]);
-        console.log(`[YjsProvider] Loaded ${rows.length} updates for room ${this.roomName}`);
-        if (rows.length > 0) {
-            Y.transact(this.doc, () => {
-                rows.forEach((row) => {
-                    const update = this.fromBase64(row.update_blob);
-                    Y.applyUpdate(this.doc, update);
-                });
-            }, this);
-        }
-    }
-    // Environment-safe Base64 helpers
-    toBase64(bytes) {
-        if (typeof Buffer !== 'undefined')
-            return Buffer.from(bytes).toString('base64');
-        let binary = '';
-        const len = bytes.byteLength;
-        for (let i = 0; i < len; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary);
-    }
-    fromBase64(str) {
-        if (typeof Buffer !== 'undefined')
-            return new Uint8Array(Buffer.from(str, 'base64'));
-        const binary = atob(str);
-        const bytes = new Uint8Array(binary.length);
-        for (let i = 0; i < binary.length; i++) {
-            bytes[i] = binary.charCodeAt(i);
-        }
-        return bytes;
-    }
-}

package/dist/src/sync/verify.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/sync/verify.js

@@ -1,23 +0,0 @@
-import * as Y from 'yjs';
-import { HybridProvider } from './hybrid-provider.js';
-async function verify() {
-    console.log('Starting verification...');
-    const doc = new Y.Doc();
-    // Use deployed relay URL
-    const provider = new HybridProvider('https://dash-relay.taylorbuley.workers.dev', 'production-test-room', doc);
-    provider.on('status', (status) => {
-        console.log('Provider Status:', status);
-    });
-    // Wait for connection
-    await new Promise(r => setTimeout(r, 2000));
-    console.log('Attempting High Frequency Mode Upgrade...');
-    await provider.enterHighFrequencyMode();
-    // Create a change
-    doc.getText('test').insert(0, 'Hello World');
-    // Wait for sync
-    await new Promise(r => setTimeout(r, 1000));
-    console.log('Verification steps executed.');
-    provider.destroy();
-    process.exit(0);
-}
-verify().catch(console.error);