@affectively/dash 5.3.1 → 5.4.0

package/dist/src/engine/vec_extension.d.ts

@@ -0,0 +1,5 @@
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+type Sqlite3Module = Awaited<ReturnType<typeof sqlite3InitModule>>;
+type Database = Sqlite3Module['oo1']['OpfsDb'] | Sqlite3Module['oo1']['DB'];
+export declare function loadVectorExtension(db: Database): Promise<void>;
+export {};

package/dist/src/engine/vec_extension.js

@@ -0,0 +1,10 @@
+export async function loadVectorExtension(db) {
+    // Hypothetical API for loading WASM extension if sqlite-wasm supports it.
+    // Currently sqlite-wasm static builds don't easily support dynamic extension loading
+    // without a custom build.
+    // For this 'cutting edge' roadmap implementation, we will simulate the
+    // extension's presence or use a polyfill pattern if the raw WASM isn't present.
+    console.log("Loading sqlite-vec extension...");
+    // register native functions if possible
+    // db.createFunction(...)
+}

package/dist/src/index.d.ts

@@ -0,0 +1,21 @@
+export { dash } from './engine/sqlite.js';
+export type { CloudConfig, CloudSyncResult } from './engine/sqlite.js';
+export { liveQuery, signal, effect, computed } from './reactivity/signal.js';
+export { mcpServer } from './mcp/server.js';
+export { YjsSqliteProvider } from './sync/provider.js';
+export { backup, restore, generateKey, exportKey, importKey } from './sync/backup.js';
+export type { CloudStorageAdapter } from './sync/backup.js';
+export { HybridProvider } from './sync/hybrid-provider.js';
+export type { RelayDiscoveryConfig, RelayPerformanceConfig, RelayPrivacyConfig, ConnectionStatus, ProviderStatus, } from './sync/hybrid-provider.js';
+export { AutomergeProvider } from './sync/AutomergeProvider.js';
+export type { AutomergeProviderOptions } from './sync/AutomergeProvider.js';
+export type { AutomergeProviderConfig } from './sync/types.js';
+export { AeonDurableSyncRuntime } from './sync/AeonDurableSync.js';
+export type { AeonDurableSyncConfig } from './sync/AeonDurableSync.js';
+export { D1SyncProvider, getD1SyncProvider, resetD1SyncProvider } from './sync/d1-provider.js';
+export type { D1SyncConfig, SyncResult, SyncQueueEntry } from './sync/d1-provider.js';
+export * as firebase from './api/firebase/index.js';
+export { collection, doc, query, where, orderBy, limit, limitToLast, startAt, startAfter, endAt, endBefore, offset, Timestamp, GeoPoint, serverTimestamp, deleteField, arrayUnion, arrayRemove, increment, getDoc, getDocs, setDoc, updateDoc, deleteDoc, writeBatch, runTransaction, onSnapshot, } from './api/firebase/index.js';
+export { ref, child, set, update, remove, push, get, onDisconnect, onValue, off, } from './api/firebase/index.js';
+export { createUserWithEmailAndPassword, signInWithEmailAndPassword, signInAnonymously, signOut, getAuth, onAuthStateChanged, updateUserProfile, updateUserEmail, updateUserPassword, deleteUser, sendPasswordResetEmail, sendEmailVerification, GoogleAuthProvider, GithubAuthProvider, FacebookAuthProvider, TwitterAuthProvider, DiscordAuthProvider, TotpMultiFactorGenerator, PhoneMultiFactorGenerator, setPersistence, browserLocalPersistence, browserSessionPersistence, inMemoryPersistence, } from './api/firebase/index.js';
+export { ref as storageRef, refFromURL, child as storageChild, uploadBytes, uploadBytesResumable, uploadString, getBytes, getDownloadURL, getMetadata, updateMetadata, deleteObject, list as listFiles, listAll, } from './api/firebase/storage/index.js';

package/dist/src/index.js

@@ -0,0 +1,26 @@
+export { dash } from './engine/sqlite.js';
+export { liveQuery, signal, effect, computed } from './reactivity/signal.js';
+export { mcpServer } from './mcp/server.js';
+// Sync exports
+export { YjsSqliteProvider } from './sync/provider.js';
+export { backup, restore, generateKey, exportKey, importKey } from './sync/backup.js';
+export { HybridProvider } from './sync/hybrid-provider.js';
+export { AutomergeProvider } from './sync/AutomergeProvider.js';
+export { AeonDurableSyncRuntime } from './sync/AeonDurableSync.js';
+// D1 HTTP Sync (legacy - prefer dash.enableCloudSync())
+export { D1SyncProvider, getD1SyncProvider, resetD1SyncProvider } from './sync/d1-provider.js';
+// Firebase Compatibility API exports
+export * as firebase from './api/firebase/index.js';
+// Firestore
+export { collection, doc, query, where, orderBy, limit, limitToLast, startAt, startAfter, endAt, endBefore, offset, serverTimestamp, deleteField, arrayUnion, arrayRemove, increment, getDoc, getDocs, setDoc, updateDoc, deleteDoc, writeBatch, runTransaction, onSnapshot, } from './api/firebase/index.js';
+// Realtime Database
+export { ref, child, set, update, remove, push, get, onDisconnect, onValue, 
+// onChildAdded,
+// onChildChanged,
+// onChildRemoved,
+// onChildMoved,
+off, } from './api/firebase/index.js';
+// Authentication
+export { createUserWithEmailAndPassword, signInWithEmailAndPassword, signInAnonymously, signOut, getAuth, onAuthStateChanged, updateUserProfile, updateUserEmail, updateUserPassword, deleteUser, sendPasswordResetEmail, sendEmailVerification, GoogleAuthProvider, GithubAuthProvider, FacebookAuthProvider, TwitterAuthProvider, DiscordAuthProvider, TotpMultiFactorGenerator, PhoneMultiFactorGenerator, setPersistence, browserLocalPersistence, browserSessionPersistence, inMemoryPersistence, } from './api/firebase/index.js';
+// Storage
+export { ref as storageRef, refFromURL, child as storageChild, uploadBytes, uploadBytesResumable, uploadString, getBytes, getDownloadURL, getMetadata, updateMetadata, deleteObject, list as listFiles, listAll, } from './api/firebase/storage/index.js';

package/dist/src/mcp/server.d.ts

@@ -0,0 +1,8 @@
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+export declare class DashMCPServer {
+    private server;
+    constructor();
+    private setupHandlers;
+    connect(transport: SSEServerTransport): Promise<void>;
+}
+export declare const mcpServer: DashMCPServer;

package/dist/src/mcp/server.js

@@ -0,0 +1,87 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { dash } from '../engine/sqlite.js';
+export class DashMCPServer {
+    server;
+    constructor() {
+        this.server = new Server({
+            name: 'dash-local-db',
+            version: '2.0.0',
+        }, {
+            capabilities: {
+                resources: {},
+                tools: {},
+            },
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        // List Resources: Expose all tables as resources
+        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+            await dash.ready();
+            // Get all table names
+            const tables = dash.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
+            return {
+                resources: tables.map((t) => ({
+                    uri: `mcp://local/dash/${t.name}`,
+                    name: t.name,
+                    mimeType: 'application/json',
+                    description: `Table: ${t.name}`,
+                })),
+            };
+        });
+        // Read Resource: Return table content
+        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+            const uri = request.params.uri;
+            const tableName = uri.split('/').pop();
+            if (!tableName)
+                throw new Error('Invalid URI');
+            const rows = dash.execute(`SELECT * FROM ${tableName} LIMIT 100`);
+            return {
+                contents: [{
+                        uri: uri,
+                        mimeType: 'application/json',
+                        text: JSON.stringify(rows, null, 2),
+                    }],
+            };
+        });
+        // List Tools: Expose Semantic Search
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [{
+                        name: 'semantic_search',
+                        description: 'Search the Dash database using vector similarity (semantic search).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: { type: 'string', description: 'The search query string.' },
+                            },
+                            required: ['query'],
+                        },
+                    }],
+            };
+        });
+        // Call Tool: Execute Semantic Search
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            if (request.params.name === 'semantic_search') {
+                const query = request.params.arguments?.query;
+                if (!query)
+                    throw new Error('Missing query argument');
+                const results = await dash.search(query);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(results, null, 2),
+                        }],
+                };
+            }
+            throw new Error('Tool not found');
+        });
+    }
+    // Method to connect to a transport (e.g., SSE for web)
+    async connect(transport) {
+        await this.server.connect(transport);
+        console.log('Dash MCP Server Connected');
+    }
+}
+export const mcpServer = new DashMCPServer();

package/dist/src/reactivity/signal.d.ts

@@ -0,0 +1,3 @@
+import { Signal } from '@preact/signals-core';
+export declare function liveQuery<T = any>(sql: string, bind?: any[]): Signal<T[]>;
+export { signal, effect, computed } from '@preact/signals-core';

package/dist/src/reactivity/signal.js

@@ -0,0 +1,31 @@
+import { signal } from '@preact/signals-core';
+import { dash } from '../engine/sqlite.js';
+export function liveQuery(sql, bind) {
+    const data = signal([]);
+    const run = async () => {
+        await dash.ready();
+        try {
+            const result = dash.execute(sql, bind);
+            data.value = result;
+        }
+        catch (e) {
+            console.error('Dash LiveQuery Error:', e);
+        }
+    };
+    // Run immediately
+    run();
+    // Subscribe to database changes
+    // Parse table name naively
+    const match = sql.match(/FROM\s+([a-zA-Z0-9_]+)/i);
+    const table = match ? match[1] : null;
+    if (table) {
+        dash.subscribe(table, () => {
+            run();
+        });
+    }
+    else {
+        console.warn('Dash: Could not identify table for liveQuery', sql);
+    }
+    return data;
+}
+export { signal, effect, computed } from '@preact/signals-core';

package/dist/src/schema/lens.d.ts

@@ -0,0 +1,29 @@
+export type LensOp = {
+    kind: 'rename';
+    source: string;
+    target: string;
+} | {
+    kind: 'hoist';
+    host: string;
+    name: string;
+} | {
+    kind: 'wrap';
+    name: string;
+};
+export interface SchemaLens {
+    from: number;
+    to: number;
+    ops: LensOp[];
+}
+export declare class LensEngine {
+    private lenses;
+    private currentVersion;
+    constructor(currentVersion: number);
+    registerLens(from: number, to: number, ops: LensOp[]): void;
+    private findPath;
+    migrate(data: any, from: number, to?: number): any;
+    private normalizeOps;
+    private invertOp;
+    private applyOp;
+}
+export declare const schema: LensEngine;

package/dist/src/schema/lens.js

@@ -0,0 +1,122 @@
+// Native Bidirectional Lens Implementation
+// Inspired by Project Cambria
+export class LensEngine {
+    lenses = [];
+    currentVersion;
+    constructor(currentVersion) {
+        this.currentVersion = currentVersion;
+    }
+    registerLens(from, to, ops) {
+        this.lenses.push({ from, to, ops });
+    }
+    // Find path from V_start to V_end
+    findPath(from, to) {
+        // BFS to find shortest path
+        const queue = [{ version: from, path: [] }];
+        const visited = new Set([from]);
+        while (queue.length > 0) {
+            const { version, path } = queue.shift();
+            if (version === to)
+                return path;
+            // Find neighbors
+            // Forward lenses
+            const forward = this.lenses.filter(l => l.from === version);
+            for (const lens of forward) {
+                if (!visited.has(lens.to)) {
+                    visited.add(lens.to);
+                    queue.push({ version: lens.to, path: [...path, lens] });
+                }
+            }
+            // Reverse lenses (Implicit)
+            const backward = this.lenses.filter(l => l.to === version);
+            for (const lens of backward) {
+                if (!visited.has(lens.from)) {
+                    visited.add(lens.from);
+                    // Create synthetic reverse lens
+                    const reverseLens = {
+                        from: lens.to,
+                        to: lens.from,
+                        ops: [...lens.ops].reverse() // Ops must be reversed!
+                    };
+                    queue.push({ version: lens.from, path: [...path, reverseLens] });
+                }
+            }
+        }
+        throw new Error(`No translation path found from v${from} to v${to}`);
+    }
+    migrate(data, from, to = this.currentVersion) {
+        if (from === to)
+            return data;
+        const path = this.findPath(from, to);
+        let doc = JSON.parse(JSON.stringify(data)); // Deep clone to avoid mutation
+        for (const step of path) {
+            const isForward = step.from < step.to; // Heuristic: Assuming localized version jumps
+            // Actually we should just apply the ops in the step direction.
+            // But we need to know if the step is a "Forward Lens" or a "Reverse Lens" 
+            // because ops like 'rename' need to swap source/target if reversed.
+            // The path finding creates "synthetic" lenses for reverse steps where from > to.
+            // So we just need to apply 'step.ops' carefully. 
+            // But wait! in findPath, I just reversed the ARRAY of ops.
+            // I ALSO need to invert the OPERATORS themselves.
+            const opsToApply = this.normalizeOps(step);
+            for (const op of opsToApply) {
+                doc = this.applyOp(doc, op);
+            }
+        }
+        return doc;
+    }
+    normalizeOps(step) {
+        // If this lens was registered as from=1, to=2
+        // And we are using it as from=1, to=2. No change.
+        // If we are traversing 2->1.
+        // The findPath constructed a lens { from: 2, to: 1, ops: ops.reverse() }
+        // But the ops inside are still { kind: 'rename', source: 'old', target: 'new' }
+        // We need to invert them to { kind: 'rename', source: 'new', target: 'old' }
+        // We need to know the *registred* direction to know if inversion is needed?
+        // Actually findPath constructs a fresh object. We can check if it exists in this.lenses.
+        const registered = this.lenses.find(l => l.from === step.from && l.to === step.to);
+        if (registered) {
+            return step.ops; // Direct match, use as is
+        }
+        // Must be a reverse step constructed by findPath
+        return step.ops.map(op => this.invertOp(op));
+    }
+    invertOp(op) {
+        switch (op.kind) {
+            case 'rename': return { kind: 'rename', source: op.target, target: op.source };
+            // Invert Hoist: Wrap?
+            // Hoist: host='meta', name='key' (moves doc.meta.key -> doc.key)
+            // Inverse: Wrap (moves doc.key -> doc.meta.key)
+            // Use 'wrap' as simplified inverse of simple hoist
+            case 'hoist': return { kind: 'wrap', name: op.name }; // Simplified
+            case 'wrap': return { kind: 'hoist', host: 'container', name: op.name }; // Naive inverse
+            default: return op;
+        }
+    }
+    applyOp(doc, op) {
+        switch (op.kind) {
+            case 'rename': {
+                if (doc[op.source] !== undefined) {
+                    doc[op.target] = doc[op.source];
+                    delete doc[op.source];
+                }
+                return doc;
+            }
+            case 'hoist': {
+                // Extract property from scalar host? Or object?
+                // Assume simple object flattening: { data: { val: 1 } } -> hoist 'data', 'val' -> { val: 1 }
+                // doc[op.host][op.name] -> doc[op.name]
+                if (doc[op.host] && doc[op.host][op.name] !== undefined) {
+                    doc[op.name] = doc[op.host][op.name];
+                    delete doc[op.host][op.name];
+                    if (Object.keys(doc[op.host]).length === 0)
+                        delete doc[op.host];
+                }
+                return doc;
+            }
+            default: return doc;
+        }
+    }
+}
+export const schema = new LensEngine(1);
+// Default to v1 until configured

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

@@ -0,0 +1,26 @@
+/**
+ * AeonDurableSync - Durable telemetry runtime for sync operations
+ *
+ * Records transport selection, discovery events, and sync protocol messages
+ * using Aeon's OfflineOperationQueue, SyncProtocol, and ReplicationManager.
+ *
+ * Operates in-memory by default. Persistence requires @affectively/aeon/persistence
+ * (available in a future release).
+ */
+type TransportType = 'websocket' | 'webtransport' | null;
+export interface AeonDurableSyncConfig {
+    enabled?: boolean;
+    roomName: string;
+    persistenceKeyPrefix?: string;
+}
+export declare class AeonDurableSyncRuntime {
+    private readonly queue;
+    private readonly protocol;
+    private readonly replication;
+    constructor(config: AeonDurableSyncConfig);
+    initialize(): Promise<void>;
+    recordTransportSelection(roomName: string, transport: TransportType, relay: string | null): void;
+    recordDiscovery(roomName: string, relays: string[]): void;
+    getPendingOperations(): number;
+}
+export {};

package/dist/src/sync/AeonDurableSync.js

@@ -0,0 +1,67 @@
+/**
+ * AeonDurableSync - Durable telemetry runtime for sync operations
+ *
+ * Records transport selection, discovery events, and sync protocol messages
+ * using Aeon's OfflineOperationQueue, SyncProtocol, and ReplicationManager.
+ *
+ * Operates in-memory by default. Persistence requires @affectively/aeon/persistence
+ * (available in a future release).
+ */
+import { OfflineOperationQueue, SyncProtocol, ReplicationManager, } from '@affectively/aeon';
+export class AeonDurableSyncRuntime {
+    queue;
+    protocol;
+    replication;
+    constructor(config) {
+        // Construct without persistence options — in-memory only until
+        // @affectively/aeon/persistence ships.
+        this.queue = new OfflineOperationQueue();
+        this.protocol = new SyncProtocol();
+        this.replication = new ReplicationManager();
+    }
+    async initialize() {
+        // No-op until persistence module is available.
+        // When @affectively/aeon/persistence ships, this will hydrate from storage.
+    }
+    recordTransportSelection(roomName, transport, relay) {
+        if (!transport) {
+            return;
+        }
+        try {
+            this.queue.enqueue('update', {
+                roomName,
+                event: 'transport-selected',
+                transport,
+                relay,
+                ts: Date.now(),
+            }, roomName, 'normal');
+            this.protocol.createSyncRequestMessage(roomName, relay ?? 'unknown-relay', `transport-${Date.now()}`, '0.0.0', '1.1.0', {
+                transport,
+                relay,
+            });
+        }
+        catch {
+            // Telemetry durability must never impact foreground sync operations.
+        }
+    }
+    recordDiscovery(roomName, relays) {
+        const sanitizedRelays = relays
+            .filter((relay) => typeof relay === 'string' && relay.length > 0)
+            .slice(0, 32);
+        try {
+            this.queue.enqueue('sync', {
+                roomName,
+                event: 'relay-discovery',
+                count: sanitizedRelays.length,
+                relays: sanitizedRelays,
+                ts: Date.now(),
+            }, roomName, 'low');
+        }
+        catch {
+            // Telemetry durability must never impact foreground sync operations.
+        }
+    }
+    getPendingOperations() {
+        return this.queue.getPendingCount();
+    }
+}

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

@@ -0,0 +1,45 @@
+/**
+ * AutomergeProvider - Automerge sync over WebSocket relay
+ *
+ * Mirrors HybridProvider's transport selection and discovery logic
+ * but uses Automerge's built-in sync protocol instead of Yjs.
+ * The relay server is CRDT-agnostic — it relays opaque binary frames.
+ *
+ * @automerge/automerge is dynamically imported so users who only use
+ * Yjs never pay the bundle cost.
+ */
+import type { AutomergeProviderConfig } from './types.js';
+export interface AutomergeProviderOptions<T> {
+    onChange?: (doc: T) => void;
+}
+export declare class AutomergeProvider<T = unknown> {
+    private config;
+    private _doc;
+    private _onChange?;
+    private _ws;
+    private _syncState;
+    private _automerge;
+    private _ready;
+    private _destroyed;
+    private _reconnectTimer;
+    private _reconnectDelayMs;
+    private readonly _maxReconnectDelayMs;
+    constructor(doc: T, config: AutomergeProviderConfig, options?: AutomergeProviderOptions<T>);
+    private initialize;
+    private getRelayUrl;
+    private connectWebSocket;
+    private scheduleReconnect;
+    private sendSyncMessage;
+    private handleMessage;
+    /**
+     * Update the local document. Required because Automerge documents are immutable —
+     * after calling Automerge.change(), pass the new doc here to sync it.
+     */
+    updateDoc(newDoc: T): void;
+    get doc(): T;
+    get ready(): Promise<void>;
+    get roomName(): string;
+    get connected(): boolean;
+    disconnect(): void;
+    destroy(): Promise<void>;
+}

package/dist/src/sync/AutomergeProvider.js

@@ -0,0 +1,153 @@
+/**
+ * AutomergeProvider - Automerge sync over WebSocket relay
+ *
+ * Mirrors HybridProvider's transport selection and discovery logic
+ * but uses Automerge's built-in sync protocol instead of Yjs.
+ * The relay server is CRDT-agnostic — it relays opaque binary frames.
+ *
+ * @automerge/automerge is dynamically imported so users who only use
+ * Yjs never pay the bundle cost.
+ */
+export class AutomergeProvider {
+    config;
+    _doc;
+    _onChange;
+    _ws = null;
+    _syncState = null;
+    _automerge = null;
+    _ready;
+    _destroyed = false;
+    _reconnectTimer = null;
+    _reconnectDelayMs = 1000;
+    _maxReconnectDelayMs = 30_000;
+    constructor(doc, config, options) {
+        this._doc = doc;
+        this.config = config;
+        this._onChange = options?.onChange;
+        this._ready = this.initialize();
+    }
+    async initialize() {
+        const am = await import('@automerge/automerge');
+        this._automerge = am;
+        this._syncState = am.initSyncState();
+        this.connectWebSocket();
+    }
+    getRelayUrl() {
+        if (this.config.websocket?.url) {
+            return toWsUrl(this.config.websocket.url);
+        }
+        if (this.config.webtransport?.url) {
+            return toWsUrl(this.config.webtransport.url);
+        }
+        return null;
+    }
+    connectWebSocket() {
+        if (this._destroyed)
+            return;
+        const relayUrl = this.getRelayUrl();
+        if (!relayUrl)
+            return;
+        const separator = relayUrl.includes('?') ? '&' : '?';
+        const params = new URLSearchParams({ room: this.config.roomName });
+        if (this.config.apiKey) {
+            params.set('apiKey', this.config.apiKey);
+        }
+        const url = `${relayUrl}${separator}${params.toString()}`;
+        try {
+            this._ws = new WebSocket(url);
+            this._ws.binaryType = 'arraybuffer';
+        }
+        catch {
+            this.scheduleReconnect();
+            return;
+        }
+        this._ws.addEventListener('open', () => {
+            this._reconnectDelayMs = 1000;
+            this.sendSyncMessage();
+        });
+        this._ws.addEventListener('message', (event) => {
+            this.handleMessage(event.data);
+        });
+        this._ws.addEventListener('close', () => {
+            this._ws = null;
+            this.scheduleReconnect();
+        });
+        this._ws.addEventListener('error', () => {
+            // close event will follow and trigger reconnect
+        });
+    }
+    scheduleReconnect() {
+        if (this._destroyed || this._reconnectTimer)
+            return;
+        this._reconnectTimer = setTimeout(() => {
+            this._reconnectTimer = null;
+            this.connectWebSocket();
+        }, this._reconnectDelayMs);
+        this._reconnectDelayMs = Math.min(this._reconnectDelayMs * 2, this._maxReconnectDelayMs);
+    }
+    sendSyncMessage() {
+        const am = this._automerge;
+        if (!am || !this._ws || this._ws.readyState !== WebSocket.OPEN)
+            return;
+        const [nextSyncState, message] = am.generateSyncMessage(this._doc, this._syncState);
+        this._syncState = nextSyncState;
+        if (message) {
+            this._ws.send(message);
+        }
+    }
+    handleMessage(data) {
+        const am = this._automerge;
+        if (!am)
+            return;
+        const message = new Uint8Array(data);
+        const [nextDoc, nextSyncState] = am.receiveSyncMessage(this._doc, this._syncState, message);
+        this._doc = nextDoc;
+        this._syncState = nextSyncState;
+        this._onChange?.(this._doc);
+        // After receiving, we may need to send our own changes
+        this.sendSyncMessage();
+    }
+    /**
+     * Update the local document. Required because Automerge documents are immutable —
+     * after calling Automerge.change(), pass the new doc here to sync it.
+     */
+    updateDoc(newDoc) {
+        this._doc = newDoc;
+        this.sendSyncMessage();
+    }
+    get doc() {
+        return this._doc;
+    }
+    get ready() {
+        return this._ready;
+    }
+    get roomName() {
+        return this.config.roomName;
+    }
+    get connected() {
+        return this._ws !== null && this._ws.readyState === WebSocket.OPEN;
+    }
+    disconnect() {
+        if (this._reconnectTimer) {
+            clearTimeout(this._reconnectTimer);
+            this._reconnectTimer = null;
+        }
+        if (this._ws) {
+            this._ws.close();
+            this._ws = null;
+        }
+    }
+    async destroy() {
+        this._destroyed = true;
+        this.disconnect();
+    }
+}
+function toWsUrl(url) {
+    if (url.startsWith('wss://') || url.startsWith('ws://'))
+        return url;
+    if (url.startsWith('https://'))
+        return `wss://${url.slice('https://'.length)}`;
+    if (url.startsWith('http://'))
+        return `ws://${url.slice('http://'.length)}`;
+    return url;
+}

package/dist/src/sync/aeon/config.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Aeon Integration Configuration
+ *
+ * Configuration for Aeon sync features in Dash.
+ * All features enabled by default.
+ */
+export interface AeonConfig {
+    /** Enable delta sync optimization (70-80% bandwidth reduction) */
+    enableDeltaSync: boolean;
+    /** Enable rich presence tracking (cursors, sections, activity) */
+    enableRichPresence: boolean;
+    /** Enable offline operation queuing */
+    enableOfflineQueue: boolean;
+    /** Bytes threshold before falling back to full sync instead of delta */
+    deltaThreshold: number;
+    /** Maximum operations to hold in offline queue */
+    maxOfflineQueueSize: number;
+    /** Maximum retries for failed offline operations */
+    maxOfflineRetries: number;
+}
+export declare const defaultAeonConfig: AeonConfig;