@affectively/dash 5.1.1 → 5.2.1

package/dist/src/engine/sqlite.js

@@ -7,6 +7,25 @@ export class DashEngine {
     listeners = new Set();
     lens = defaultLens;
     currentSchemaVersion = 1;
+    // Cloud sync state
+    cloudConfig = null;
+    cloudSyncTimer = null;
+    isCloudSyncing = false;
+    lastCloudSyncTime = 0;
+    cloudSyncEnabled = false;
+    syncedTables = new Set();
+    // Internal tables that should never sync
+    INTERNAL_TABLES = new Set([
+        'dash_metadata',
+        'dash_items',
+        'dash_vec_idx',
+        'dash_spatial_idx',
+        'dash_spatial_map',
+        'dash_sync_meta',
+        'dash_sync_queue',
+        'dash_sync_updates',
+        'sqlite_sequence',
+    ]);
     constructor() {
         // SSR/Build safety: Only initialize in browser environments
         if (typeof window !== 'undefined') {
@@ -31,12 +50,111 @@ export class DashEngine {
             // Load Vector Extension (Simulation/Shim for now)
             await import('./vec_extension.js').then(m => m.loadVectorExtension(this.db));
             this.initializeSchema();
+            // Auto-enable cloud sync if endpoint is available (ON BY DEFAULT)
+            this.tryAutoEnableCloudSync();
         }
         catch (err) {
             console.error('Dash: Failed to initialize SQLite WASM', err);
             throw err;
         }
     }
+    /**
+     * Try to auto-enable cloud sync from environment
+     * Cloud sync is ON BY DEFAULT when a sync endpoint is detected
+     */
+    tryAutoEnableCloudSync() {
+        try {
+            // Detect sync endpoint from various sources
+            const syncUrl = this.detectSyncEndpoint();
+            if (!syncUrl) {
+                console.log('[Dash] No sync endpoint detected, cloud sync disabled');
+                return;
+            }
+            // Auto-enable with default config
+            this.enableCloudSync({
+                baseUrl: syncUrl,
+                getAuthToken: async () => this.getDefaultAuthToken(),
+                syncInterval: 30000,
+                onSyncError: (err) => {
+                    // Graceful degradation - just log, don't crash
+                    console.warn('[Dash] Cloud sync failed (graceful degradation):', err.message);
+                },
+            });
+            console.log('[Dash] Cloud sync auto-enabled:', syncUrl);
+        }
+        catch (err) {
+            // Graceful degradation - local-first still works
+            console.warn('[Dash] Could not auto-enable cloud sync:', err);
+        }
+    }
+    /**
+     * Detect sync endpoint from environment variables or same-origin
+     */
+    detectSyncEndpoint() {
+        // Check various env var patterns
+        const envVars = [
+            'DASH_SYNC_URL',
+            'NEXT_PUBLIC_DASH_SYNC_URL',
+            'VITE_DASH_SYNC_URL',
+            'DASH_API_URL',
+            'NEXT_PUBLIC_API_URL',
+            'VITE_API_URL',
+        ];
+        // Try globalThis.process.env (Node/Next.js)
+        if (typeof globalThis !== 'undefined' && globalThis.process?.env) {
+            const env = globalThis.process.env;
+            for (const key of envVars) {
+                if (env[key])
+                    return env[key];
+            }
+        }
+        // Try import.meta.env (Vite)
+        if (typeof import.meta !== 'undefined' && import.meta.env) {
+            const env = import.meta.env;
+            for (const key of envVars) {
+                if (env[key])
+                    return env[key];
+            }
+        }
+        // Try window.__ENV__ (runtime injection)
+        if (typeof window !== 'undefined' && window.__ENV__) {
+            const env = window.__ENV__;
+            for (const key of envVars) {
+                if (env[key])
+                    return env[key];
+            }
+        }
+        // Auto-detect same-origin sync for Cloudflare/edge deployments
+        // If running in browser, use same origin as sync endpoint
+        if (typeof window !== 'undefined' && window.location?.origin) {
+            // Only auto-enable for HTTPS (production) or localhost (dev)
+            const origin = window.location.origin;
+            if (origin.startsWith('https://') || origin.includes('localhost') || origin.includes('127.0.0.1')) {
+                return origin;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get default auth token from common auth patterns
+     */
+    async getDefaultAuthToken() {
+        try {
+            // Try localStorage token
+            if (typeof localStorage !== 'undefined') {
+                const token = localStorage.getItem('auth_token') ||
+                    localStorage.getItem('access_token') ||
+                    localStorage.getItem('id_token');
+                if (token)
+                    return token;
+            }
+            // Try cookie-based auth (will be sent automatically)
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
     initializeSchema() {
         if (!this.db)
             return;
@@ -119,6 +237,7 @@ export class DashEngine {
         // Matches: INSERT INTO table ...
         // Matches: UPDATE table ...
         // Matches: DELETE FROM table ...
+        // Matches: CREATE TABLE table ...
         let table = '';
         if (upper.startsWith('INSERT INTO')) {
             table = sql.split(/\s+/)[2];
@@ -129,6 +248,22 @@ export class DashEngine {
         else if (upper.startsWith('DELETE FROM')) {
             table = sql.split(/\s+/)[2];
         }
+        else if (upper.startsWith('CREATE TABLE')) {
+            // Extract table name from CREATE TABLE [IF NOT EXISTS] tablename
+            const match = sql.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?(\w+)["']?/i);
+            if (match) {
+                table = match[1];
+                // Auto-setup cloud sync triggers for new tables
+                if (this.cloudSyncEnabled && this.shouldSyncTable(table) && !this.syncedTables.has(table)) {
+                    // Defer trigger setup to after the table is created
+                    setTimeout(() => {
+                        this.setupTableSyncTriggers(table);
+                        this.syncedTables.add(table);
+                        console.log('[Dash] Auto-enabled cloud sync for new table:', table);
+                    }, 0);
+                }
+            }
+        }
         if (table) {
             // cleanup quotes etc
             table = table.replace(/["';]/g, '');
@@ -250,9 +385,408 @@ export class DashEngine {
         });
     }
     close() {
+        this.stopCloudSync();
         this.db?.close();
     }
     // ============================================
+    // CLOUD SYNC (D1/R2) - AUTOMATIC SYNC
+    // ============================================
+    /**
+     * Enable cloud sync - changes automatically sync to D1/R2
+     * Just call this once with your config, and sync happens magically.
+     *
+     * Cloud sync is ON BY DEFAULT when running in a Cloudflare environment.
+     * Call this to customize the config or explicitly enable/disable.
+     *
+     * @example
+     * ```ts
+     * await dash.ready();
+     * // Option 1: Use auto-detected endpoint (default)
+     * // Cloud sync is already enabled if DASH_SYNC_URL env var is set
+     *
+     * // Option 2: Explicit config
+     * dash.enableCloudSync({
+     *   baseUrl: 'https://api.example.com',
+     *   getAuthToken: async () => auth.token,
+     * });
+     *
+     * // Option 3: Disable cloud sync
+     * dash.enableCloudSync({ disabled: true });
+     * ```
+     */
+    enableCloudSync(config = {}) {
+        // Handle explicit disable
+        if (config.disabled) {
+            this.disableCloudSync();
+            return;
+        }
+        if (!this.db) {
+            console.warn('[Dash] Database not ready. Call enableCloudSync after ready()');
+            return;
+        }
+        // Try to get baseUrl from config or auto-detect
+        const baseUrl = config.baseUrl || this.detectSyncEndpoint();
+        if (!baseUrl) {
+            console.warn('[Dash] No sync endpoint available. Cloud sync disabled.');
+            return;
+        }
+        this.cloudConfig = {
+            syncInterval: 30000,
+            ...config,
+            baseUrl,
+            getAuthToken: config.getAuthToken || (() => this.getDefaultAuthToken()),
+        };
+        // Create sync infrastructure tables
+        this.initializeCloudSyncSchema();
+        // Load last sync time
+        const meta = this.execute("SELECT value FROM dash_sync_meta WHERE key = 'lastCloudSyncTime'");
+        if (meta.length > 0) {
+            this.lastCloudSyncTime = parseInt(meta[0].value, 10) || 0;
+        }
+        // Set up triggers for all existing user tables
+        this.setupAllTableTriggers();
+        this.cloudSyncEnabled = true;
+        // Start auto-sync
+        if (this.cloudConfig.syncInterval && this.cloudConfig.syncInterval > 0) {
+            this.startCloudSync();
+        }
+        console.log('[Dash] Cloud sync enabled');
+    }
+    /**
+     * Initialize cloud sync schema (queue and metadata tables)
+     */
+    initializeCloudSyncSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS dash_sync_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT
+      )
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS dash_sync_queue (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        table_name TEXT NOT NULL,
+        row_id TEXT NOT NULL,
+        operation TEXT NOT NULL CHECK(operation IN ('create', 'update', 'delete')),
+        data TEXT,
+        created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
+        synced INTEGER DEFAULT 0
+      )
+    `);
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_dash_sync_queue_pending
+      ON dash_sync_queue(synced, created_at)
+    `);
+    }
+    /**
+     * Set up sync triggers for all user tables
+     */
+    setupAllTableTriggers() {
+        const tables = this.execute(`
+      SELECT name FROM sqlite_master
+      WHERE type = 'table'
+      AND name NOT LIKE 'sqlite_%'
+    `);
+        for (const t of tables) {
+            const tableName = t.name;
+            if (!this.shouldSyncTable(tableName))
+                continue;
+            this.setupTableSyncTriggers(tableName);
+            this.syncedTables.add(tableName);
+        }
+        console.log('[Dash] Sync triggers set up for:', Array.from(this.syncedTables));
+    }
+    /**
+     * Check if a table should be synced
+     */
+    shouldSyncTable(tableName) {
+        // Skip internal tables
+        if (this.INTERNAL_TABLES.has(tableName))
+            return false;
+        // Skip excluded tables
+        if (this.cloudConfig?.excludeTables?.includes(tableName))
+            return false;
+        return true;
+    }
+    /**
+     * Set up sync triggers for a specific table
+     */
+    setupTableSyncTriggers(tableName) {
+        // Check if table has an 'id' column (required for sync)
+        const columns = this.execute(`PRAGMA table_info('${tableName.replace(/'/g, "''")}')`);
+        const hasId = columns.some((c) => c.name === 'id');
+        if (!hasId) {
+            console.warn(`[Dash] Table ${tableName} has no 'id' column, skipping sync triggers`);
+            return;
+        }
+        // Drop existing triggers
+        try {
+            this.db.exec(`DROP TRIGGER IF EXISTS dash_cloud_${tableName}_insert`);
+            this.db.exec(`DROP TRIGGER IF EXISTS dash_cloud_${tableName}_update`);
+            this.db.exec(`DROP TRIGGER IF EXISTS dash_cloud_${tableName}_delete`);
+        }
+        catch {
+            // Ignore
+        }
+        // INSERT trigger - capture full row as JSON
+        this.db.exec(`
+      CREATE TRIGGER dash_cloud_${tableName}_insert
+      AFTER INSERT ON "${tableName}"
+      WHEN (SELECT value FROM dash_sync_meta WHERE key = 'cloud_enabled') = '1'
+      BEGIN
+        INSERT INTO dash_sync_queue (table_name, row_id, operation, data)
+        SELECT '${tableName}', NEW.id, 'create', json_object(${this.buildJsonObjectArgs(tableName, columns, 'NEW')});
+      END
+    `);
+        // UPDATE trigger
+        this.db.exec(`
+      CREATE TRIGGER dash_cloud_${tableName}_update
+      AFTER UPDATE ON "${tableName}"
+      WHEN (SELECT value FROM dash_sync_meta WHERE key = 'cloud_enabled') = '1'
+      BEGIN
+        INSERT INTO dash_sync_queue (table_name, row_id, operation, data)
+        SELECT '${tableName}', NEW.id, 'update', json_object(${this.buildJsonObjectArgs(tableName, columns, 'NEW')});
+      END
+    `);
+        // DELETE trigger
+        this.db.exec(`
+      CREATE TRIGGER dash_cloud_${tableName}_delete
+      AFTER DELETE ON "${tableName}"
+      WHEN (SELECT value FROM dash_sync_meta WHERE key = 'cloud_enabled') = '1'
+      BEGIN
+        INSERT INTO dash_sync_queue (table_name, row_id, operation, data)
+        VALUES ('${tableName}', OLD.id, 'delete', NULL);
+      END
+    `);
+        // Enable triggers
+        this.execute("INSERT OR REPLACE INTO dash_sync_meta (key, value) VALUES ('cloud_enabled', '1')");
+    }
+    /**
+     * Build json_object() arguments for a table's columns
+     */
+    buildJsonObjectArgs(tableName, columns, prefix) {
+        return columns
+            .map((c) => `'${c.name}', ${prefix}."${c.name}"`)
+            .join(', ');
+    }
+    /**
+     * Start automatic cloud sync
+     */
+    startCloudSync() {
+        if (this.cloudSyncTimer)
+            return;
+        this.cloudSyncTimer = setInterval(() => {
+            if (typeof navigator !== 'undefined' && !navigator.onLine) {
+                return; // Skip sync when offline
+            }
+            this.syncToCloud().catch(console.error);
+        }, this.cloudConfig.syncInterval);
+        // Also do an immediate sync
+        this.syncToCloud().catch(console.error);
+        console.log('[Dash] Cloud auto-sync started, interval:', this.cloudConfig.syncInterval, 'ms');
+    }
+    /**
+     * Stop automatic cloud sync
+     */
+    stopCloudSync() {
+        if (this.cloudSyncTimer) {
+            clearInterval(this.cloudSyncTimer);
+            this.cloudSyncTimer = null;
+        }
+        this.cloudSyncEnabled = false;
+        console.log('[Dash] Cloud sync stopped');
+    }
+    /**
+     * Perform a sync to cloud (D1/R2)
+     */
+    async syncToCloud() {
+        if (!this.cloudConfig || !this.cloudSyncEnabled) {
+            return { pushed: 0, pulled: 0, errors: ['Cloud sync not enabled'], timestamp: Date.now() };
+        }
+        if (this.isCloudSyncing) {
+            return { pushed: 0, pulled: 0, errors: ['Sync already in progress'], timestamp: Date.now() };
+        }
+        this.isCloudSyncing = true;
+        const result = { pushed: 0, pulled: 0, errors: [], timestamp: Date.now() };
+        try {
+            const token = this.cloudConfig.getAuthToken
+                ? await this.cloudConfig.getAuthToken()
+                : await this.getDefaultAuthToken();
+            // Token is optional - sync can work without auth for public endpoints
+            // Get pending changes
+            const pending = this.execute(`
+        SELECT * FROM dash_sync_queue
+        WHERE synced = 0
+        ORDER BY created_at ASC
+        LIMIT 100
+      `);
+            // Group by table
+            const changesByTable = {};
+            for (const entry of pending) {
+                const tableName = entry.table_name;
+                if (!changesByTable[tableName]) {
+                    changesByTable[tableName] = { creates: [], updates: [], deletes: [] };
+                }
+                const data = entry.data ? JSON.parse(entry.data) : null;
+                switch (entry.operation) {
+                    case 'create':
+                        if (data)
+                            changesByTable[tableName].creates.push(data);
+                        break;
+                    case 'update':
+                        if (data)
+                            changesByTable[tableName].updates.push(data);
+                        break;
+                    case 'delete':
+                        changesByTable[tableName].deletes.push(entry.row_id);
+                        break;
+                }
+            }
+            // Sync each table
+            for (const [tableName, changes] of Object.entries(changesByTable)) {
+                if (changes.creates.length === 0 && changes.updates.length === 0 && changes.deletes.length === 0) {
+                    continue;
+                }
+                try {
+                    const headers = {
+                        'Content-Type': 'application/json',
+                    };
+                    if (token) {
+                        headers['Authorization'] = `Bearer ${token}`;
+                    }
+                    const response = await fetch(`${this.cloudConfig.baseUrl}/api/sync`, {
+                        method: 'POST',
+                        headers,
+                        body: JSON.stringify({
+                            table: tableName,
+                            creates: changes.creates,
+                            updates: changes.updates,
+                            deletes: changes.deletes,
+                            lastSyncTime: this.lastCloudSyncTime,
+                        }),
+                    });
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        result.errors.push(`${tableName}: ${response.status} ${errorText}`);
+                        continue;
+                    }
+                    const syncResponse = await response.json();
+                    result.pushed += changes.creates.length + changes.updates.length + changes.deletes.length;
+                    result.pulled += syncResponse.serverChanges?.length || 0;
+                    // Apply server changes locally (with triggers disabled)
+                    if (syncResponse.serverChanges && syncResponse.serverChanges.length > 0) {
+                        this.execute("UPDATE dash_sync_meta SET value = '0' WHERE key = 'cloud_enabled'");
+                        try {
+                            for (const change of syncResponse.serverChanges) {
+                                this.applyServerChange(tableName, change);
+                            }
+                        }
+                        finally {
+                            this.execute("UPDATE dash_sync_meta SET value = '1' WHERE key = 'cloud_enabled'");
+                        }
+                    }
+                    // Update sync time
+                    if (syncResponse.syncTime > this.lastCloudSyncTime) {
+                        this.lastCloudSyncTime = syncResponse.syncTime;
+                        this.execute("INSERT OR REPLACE INTO dash_sync_meta (key, value) VALUES ('lastCloudSyncTime', ?)", [String(this.lastCloudSyncTime)]);
+                    }
+                }
+                catch (err) {
+                    result.errors.push(`${tableName}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            // Mark as synced
+            if (pending.length > 0) {
+                const ids = pending.map((e) => e.id).join(',');
+                this.execute(`UPDATE dash_sync_queue SET synced = 1 WHERE id IN (${ids})`);
+            }
+            // Clean up old entries
+            this.execute(`
+        DELETE FROM dash_sync_queue
+        WHERE synced = 1
+        AND id NOT IN (
+          SELECT id FROM dash_sync_queue
+          WHERE synced = 1
+          ORDER BY id DESC
+          LIMIT 1000
+        )
+      `);
+            this.cloudConfig.onSyncComplete?.(result);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            result.errors.push(error.message);
+            this.cloudConfig.onSyncError?.(error);
+        }
+        finally {
+            this.isCloudSyncing = false;
+        }
+        return result;
+    }
+    /**
+     * Apply a single server change locally
+     */
+    applyServerChange(tableName, change) {
+        try {
+            if (change.deleted || change._deleted) {
+                this.execute(`DELETE FROM "${tableName}" WHERE id = ?`, [change.id]);
+                return;
+            }
+            const columns = Object.keys(change).filter(k => !k.startsWith('_'));
+            const placeholders = columns.map(() => '?').join(', ');
+            const values = columns.map(k => {
+                const v = change[k];
+                if (v !== null && typeof v === 'object') {
+                    return JSON.stringify(v);
+                }
+                return v;
+            });
+            const sql = `INSERT OR REPLACE INTO "${tableName}" (${columns.join(', ')}) VALUES (${placeholders})`;
+            this.execute(sql, values);
+        }
+        catch (err) {
+            console.error(`[Dash] Failed to apply server change to ${tableName}:`, err);
+        }
+    }
+    /**
+     * Force a full cloud sync (reset last sync time)
+     */
+    async forceCloudSync() {
+        this.lastCloudSyncTime = 0;
+        this.execute("INSERT OR REPLACE INTO dash_sync_meta (key, value) VALUES ('lastCloudSyncTime', '0')");
+        return this.syncToCloud();
+    }
+    /**
+     * Get cloud sync status
+     */
+    getCloudSyncStatus() {
+        let pendingChanges = 0;
+        if (this.cloudSyncEnabled && this.db) {
+            try {
+                const result = this.execute('SELECT COUNT(*) as count FROM dash_sync_queue WHERE synced = 0');
+                pendingChanges = result[0]?.count || 0;
+            }
+            catch {
+                // Table might not exist yet
+            }
+        }
+        return {
+            enabled: this.cloudSyncEnabled,
+            syncing: this.isCloudSyncing,
+            lastSyncTime: this.lastCloudSyncTime,
+            pendingChanges,
+            syncedTables: Array.from(this.syncedTables),
+        };
+    }
+    /**
+     * Disable cloud sync
+     */
+    disableCloudSync() {
+        this.stopCloudSync();
+        this.execute("UPDATE dash_sync_meta SET value = '0' WHERE key = 'cloud_enabled'");
+        console.log('[Dash] Cloud sync disabled');
+    }
+    // ============================================
     // INTROSPECTION METHODS FOR DASH-STUDIO
     // ============================================
     /**

package/dist/src/index.d.ts

@@ -1,12 +1,15 @@
 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 { 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, onChildAdded, onChildChanged, onChildRemoved, onChildMoved, off, } 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/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

@@ -5,13 +5,20 @@ export { mcpServer } from './mcp/server.js';
 export { YjsSqliteProvider } from './sync/provider.js';
 export { backup, restore, generateKey, exportKey, importKey } from './sync/backup.js';
 export { HybridProvider } from './sync/hybrid-provider.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';
+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/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';