@affectively/dash 5.4.1 → 5.4.5

package/dist/src/engine/sqlite.js

@@ -1,1328 +0,0 @@
-// import sqlite3InitModule from '@sqlite.org/sqlite-wasm'; // moved to dynamic import
-import { vectorEngine } from './ai.js';
-import { schema as defaultLens } from '../schema/lens.js';
-import * as Y from 'yjs';
-export class DashEngine {
-    db = null;
-    readyPromise;
-    listeners = new Set();
-    lens = defaultLens;
-    currentSchemaVersion = 1;
-    // Cloud sync state (D1)
-    cloudConfig = null;
-    cloudSyncTimer = null;
-    isCloudSyncing = false;
-    lastCloudSyncTime = 0;
-    cloudSyncEnabled = false;
-    syncedTables = new Set();
-    // Relay sync state (Real-time)
-    relayProvider = null; // HybridProvider instance
-    relayDoc = null;
-    relaySyncEnabled = false;
-    // 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') {
-            this.readyPromise = this.init();
-        }
-        else {
-            this.readyPromise = Promise.resolve();
-        }
-    }
-    async init() {
-        try {
-            const sqlite3InitModule = (await import('@sqlite.org/sqlite-wasm')).default;
-            const sqlite3 = await sqlite3InitModule();
-            if ('opfs' in sqlite3) {
-                this.db = new sqlite3.oo1.OpfsDb('/dash.db');
-                console.log('Dash: SQLite OPFS database opened.');
-            }
-            else {
-                console.warn('Dash: OPFS is not available. Falling back to transient storage.');
-                this.db = new sqlite3.oo1.DB('/dash-memory.db', 'ct');
-            }
-            // 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;
-    }
-    /**
-     * Detect relay endpoint from environment variables
-     */
-    detectRelayEndpoint() {
-        // Check various env var patterns for relay
-        const envVars = [
-            'DASH_RELAY_URL',
-            'NEXT_PUBLIC_DASH_RELAY_URL',
-            'VITE_DASH_RELAY_URL',
-            'DASH_RELAY_WS_URL',
-            'NEXT_PUBLIC_DASH_RELAY_WS_URL',
-            'VITE_DASH_RELAY_WS_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 relay for Cloudflare/edge deployments
-        // Convert HTTP origin to WS URL
-        if (typeof window !== 'undefined' && window.location?.origin) {
-            const origin = window.location.origin;
-            if (origin.startsWith('https://')) {
-                return origin.replace('https://', 'wss://');
-            }
-            else if (origin.includes('localhost') || origin.includes('127.0.0.1')) {
-                return origin.replace('http://', 'ws://');
-            }
-        }
-        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;
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS dash_metadata (
-        key TEXT PRIMARY KEY,
-        value TEXT
-      );
-      CREATE TABLE IF NOT EXISTS dash_items (
-        id TEXT PRIMARY KEY,
-        content TEXT
-      );
-      -- Spatial Index (R-Tree) for 3D coordinates
-    `);
-        // Create Virtual Tables separately as they might fail if extensions (vec0, rtree) are missing
-        try {
-            this.db.exec(`
-          CREATE VIRTUAL TABLE IF NOT EXISTS dash_vec_idx USING vec0(
-            id TEXT PRIMARY KEY,
-            embedding float[384]
-          );
-        `);
-        }
-        catch (e) {
-            console.warn('Dash: Failed to create vec0 table (vector extension missing?)', e);
-        }
-        try {
-            this.db.exec(`
-          CREATE VIRTUAL TABLE IF NOT EXISTS dash_spatial_idx USING rtree(
-            id,             -- Integer Primary Key (mapped or auto)
-            minX, maxX,
-            minY, maxY,
-            minZ, maxZ
-          );
-        `);
-        }
-        catch (e) {
-            console.warn('Dash: Failed to create rtree table', e);
-        }
-        this.db.exec(`
-      -- Mapping table since R-Tree requires integer IDs
-      CREATE TABLE IF NOT EXISTS dash_spatial_map (
-        rowid INTEGER PRIMARY KEY,
-        item_id TEXT UNIQUE
-      );
-    `);
-    }
-    async ready() {
-        return this.readyPromise;
-    }
-    tableListeners = new Map();
-    subscribe(table, callback) {
-        if (!this.tableListeners.has(table)) {
-            this.tableListeners.set(table, new Set());
-        }
-        this.tableListeners.get(table).add(callback);
-        return () => {
-            const set = this.tableListeners.get(table);
-            if (set) {
-                set.delete(callback);
-                if (set.size === 0)
-                    this.tableListeners.delete(table);
-            }
-        };
-    }
-    notify(table) {
-        if (this.tableListeners.has(table)) {
-            this.tableListeners.get(table).forEach(cb => cb());
-        }
-        // Also notify global listeners (optional, but good for debugging)
-        this.listeners.forEach(cb => cb());
-    }
-    // Hook into SQLite updates
-    // In a real WASM build we would use db.updateHook((type, dbName, tableName, rowid) => ...)
-    // For this implementation effectively utilizing the "update_hook" concept via our execute wrapper
-    // which is safer across different sqlite-wasm build versions (some minimal builds exclude hooks).
-    notifyChanges(sql, bind) {
-        const upper = sql.trim().toUpperCase();
-        // Naive table parser for MVP
-        // Matches: INSERT INTO table ...
-        // Matches: UPDATE table ...
-        // Matches: DELETE FROM table ...
-        // Matches: CREATE TABLE table ...
-        let table = '';
-        let operation = null;
-        let rowId = null;
-        if (upper.startsWith('INSERT INTO')) {
-            table = sql.split(/\s+/)[2];
-            operation = 'create';
-        }
-        else if (upper.startsWith('UPDATE')) {
-            table = sql.split(/\s+/)[1];
-            operation = 'update';
-        }
-        else if (upper.startsWith('DELETE FROM')) {
-            table = sql.split(/\s+/)[2];
-            operation = 'delete';
-        }
-        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, '');
-            this.notify(table);
-            // === Relay Sync: Broadcast changes in real-time ===
-            // For Relay, we want immediate updates (not batched like D1)
-            if (this.relaySyncEnabled && operation && this.shouldSyncTable(table)) {
-                // Try to extract row ID from bind parameters or the SQL
-                // For INSERT/UPDATE, bind[0] is often the id
-                if (bind && bind.length > 0) {
-                    // Check if first param looks like an id
-                    const firstParam = bind[0];
-                    if (typeof firstParam === 'string' && firstParam.length > 0) {
-                        rowId = firstParam;
-                    }
-                }
-                // If we have a row ID, get the full row data and broadcast
-                if (rowId && operation !== 'delete') {
-                    try {
-                        const row = this.execute(`SELECT * FROM "${table}" WHERE id = ?`, [rowId]);
-                        if (row.length > 0) {
-                            this.broadcastToRelay(table, rowId, operation, row[0]);
-                        }
-                    }
-                    catch {
-                        // Ignore - table might not have id column
-                    }
-                }
-                else if (rowId && operation === 'delete') {
-                    this.broadcastToRelay(table, rowId, 'delete', null);
-                }
-            }
-        }
-    }
-    execute(sql, bind) {
-        if (!this.db)
-            throw new Error('Database not initialized');
-        const result = [];
-        this.db.exec({
-            sql,
-            bind,
-            rowMode: 'object',
-            callback: (row) => {
-                result.push(row);
-            },
-        });
-        this.notifyChanges(sql, bind);
-        return result;
-    }
-    // Zero-Copy Binding Implementation
-    // Returns a flat Float32Array of the results. 
-    // Ideal for passing directly to WebGL/WebGPU buffers.
-    getFloat32(sql, bind) {
-        if (!this.db)
-            throw new Error('Database not initialized');
-        const result = [];
-        this.db.exec({
-            sql,
-            bind,
-            rowMode: 'array',
-            callback: (row) => {
-                for (const val of row) {
-                    result.push(val);
-                }
-            }
-        });
-        return new Float32Array(result);
-    }
-    async addWithEmbedding(id, content, spatial) {
-        const vector = await vectorEngine.embed(content);
-        this.db.exec('BEGIN TRANSACTION');
-        try {
-            this.execute('INSERT OR REPLACE INTO dash_items (id, content) VALUES (?, ?)', [id, content]);
-            this.execute('INSERT OR REPLACE INTO dash_vec_idx(id, embedding) VALUES (?, ?)', [id, vector]);
-            if (spatial) {
-                // Map text ID to integer rowid
-                this.execute('INSERT OR IGNORE INTO dash_spatial_map (item_id) VALUES (?)', [id]);
-                const rowMap = this.execute('SELECT rowid FROM dash_spatial_map WHERE item_id = ?', [id]);
-                if (rowMap.length > 0) {
-                    const rid = rowMap[0].rowid;
-                    // R-Tree insert
-                    // Treat point as box with 0 size or small epsilon
-                    const r = 0.001;
-                    this.execute('INSERT OR REPLACE INTO dash_spatial_idx (id, minX, maxX, minY, maxY, minZ, maxZ) VALUES (?, ?, ?, ?, ?, ?, ?)', [rid, spatial.x - r, spatial.x + r, spatial.y - r, spatial.y + r, spatial.z - r, spatial.z + r]);
-                }
-            }
-            this.db.exec('COMMIT');
-        }
-        catch (e) {
-            this.db.exec('ROLLBACK');
-            throw e;
-        }
-        return [];
-    }
-    async search(query, limit = 5) {
-        const queryVector = await vectorEngine.embed(query);
-        try {
-            const rows = this.execute(`
-            SELECT
-                item.id,
-                item.content,
-                distance,
-                dash_metadata.value as _v 
-            FROM dash_vec_idx
-            JOIN dash_items AS item ON item.id = dash_vec_idx.id
-            LEFT JOIN dash_metadata ON dash_metadata.key = 'schema_version_' || item.id 
-            WHERE embedding MATCH ?
-            ORDER BY distance
-            LIMIT ?
-        `, [queryVector, limit]);
-            // Normalize distance to score (assuming Cosine Distance: score = 1 - distance)
-            return rows.map((row) => {
-                // Apply Lens Migration if version differs
-                // Default to v1 if no version metadata found
-                const version = row._v ? parseInt(row._v) : 1;
-                const migrated = this.lens.migrate(row, version, this.currentSchemaVersion);
-                return {
-                    ...migrated,
-                    score: row.distance !== undefined ? 1 - row.distance : 0
-                };
-            });
-        }
-        catch (e) {
-            console.warn("Vector search failed, using fallback", e);
-            return [];
-        }
-    }
-    async spatialQuery(bounds) {
-        const rows = this.execute(`
-        SELECT
-            map.item_id as id,
-            item.content,
-            idx.minX, idx.maxX, idx.minY, idx.maxY, idx.minZ, idx.maxZ,
-            meta.value as _v
-        FROM dash_spatial_idx AS idx
-        JOIN dash_spatial_map AS map ON map.rowid = idx.id
-        JOIN dash_items AS item ON item.id = map.item_id
-        LEFT JOIN dash_metadata AS meta ON meta.key = 'schema_version_' || item.id
-        WHERE
-            minX >= ? AND maxX <= ? AND
-            minY >= ? AND maxY <= ? AND
-            minZ >= ? AND maxZ <= ?
-      `, [bounds.minX, bounds.maxX, bounds.minY, bounds.maxY, bounds.minZ, bounds.maxZ]);
-        return rows.map(row => {
-            const version = row._v ? parseInt(row._v) : 1;
-            return this.lens.migrate(row, version, this.currentSchemaVersion);
-        });
-    }
-    close() {
-        this.stopCloudSync();
-        this.stopRelaySync();
-        this.db?.close();
-    }
-    /**
-     * Stop Relay sync
-     */
-    stopRelaySync() {
-        if (this.relayProvider) {
-            this.relayProvider.destroy();
-            this.relayProvider = null;
-        }
-        if (this.relayDoc) {
-            this.relayDoc.destroy();
-            this.relayDoc = null;
-        }
-        this.relaySyncEnabled = false;
-        console.log('[Dash] Relay sync stopped');
-    }
-    // ============================================
-    // 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();
-        const relayUrl = config.relayUrl || this.detectRelayEndpoint();
-        // Need at least one sync method
-        if (!baseUrl && !relayUrl) {
-            console.warn('[Dash] No sync endpoints available. Cloud sync disabled.');
-            return;
-        }
-        this.cloudConfig = {
-            syncInterval: 30000,
-            ...config,
-            baseUrl: baseUrl || undefined,
-            relayUrl: relayUrl || undefined,
-            getAuthToken: config.getAuthToken || (() => this.getDefaultAuthToken()),
-        };
-        // === D1 Sync Setup (Persistence) ===
-        if (baseUrl && !config.disableD1) {
-            // 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] D1 sync enabled:', baseUrl);
-        }
-        // === Relay Sync Setup (Real-time) ===
-        if (relayUrl && !config.disableRelay) {
-            this.initializeRelaySync(relayUrl, config).catch(err => {
-                console.warn('[Dash] Relay sync failed to initialize (graceful degradation):', err.message);
-            });
-        }
-    }
-    /**
-     * Initialize Relay sync for real-time updates
-     */
-    async initializeRelaySync(relayUrl, config) {
-        try {
-            // Dynamically import HybridProvider to avoid circular dependencies
-            const { HybridProvider } = await import('../sync/hybrid-provider.js');
-            // Create Yjs document for relay sync
-            this.relayDoc = new Y.Doc();
-            // Get room name
-            const roomName = config.relayRoom || `dash-${config.userId || 'default'}`;
-            // Initialize HybridProvider
-            this.relayProvider = new HybridProvider(relayUrl, roomName, this.relayDoc, {
-                aeonConfig: {
-                    enableDeltaSync: true,
-                    enableRichPresence: true,
-                    enableOfflineQueue: true,
-                    deltaThreshold: 64, // Compress updates > 64 bytes
-                    maxOfflineQueueSize: 1000,
-                    maxOfflineRetries: 5,
-                },
-                relayDiscovery: config.relayDiscovery,
-                relayPerformance: config.relayPerformance,
-                relayPrivacy: config.relayPrivacy,
-            });
-            // Listen for remote changes and apply to local SQLite
-            this.relayDoc.on('update', (update, origin) => {
-                if (origin === 'local')
-                    return; // Skip our own updates
-                this.applyRelayUpdate(update);
-            });
-            // Enter high-frequency mode if requested
-            if (config.relayHighFrequency) {
-                await this.relayProvider.enterHighFrequencyMode();
-            }
-            this.relaySyncEnabled = true;
-            console.log('[Dash] Relay sync enabled:', relayUrl, '(room:', roomName, ')');
-        }
-        catch (err) {
-            throw err;
-        }
-    }
-    /**
-     * Apply an update from Relay to local SQLite
-     */
-    applyRelayUpdate(update) {
-        if (!this.relayDoc)
-            return;
-        try {
-            // Get the shared map that contains table updates
-            const tablesMap = this.relayDoc.getMap('tables');
-            // Process each table's updates
-            tablesMap.forEach((tableData, tableName) => {
-                if (!this.shouldSyncTable(tableName))
-                    return;
-                // Apply each row update
-                const rowsMap = tableData;
-                rowsMap.forEach((rowData, rowId) => {
-                    this.applyServerChange(tableName, { id: rowId, ...rowData });
-                });
-            });
-        }
-        catch (err) {
-            console.warn('[Dash] Failed to apply relay update:', err);
-        }
-    }
-    /**
-     * Broadcast a local change to Relay
-     */
-    broadcastToRelay(tableName, rowId, operation, data) {
-        if (!this.relayDoc || !this.relaySyncEnabled)
-            return;
-        try {
-            const tablesMap = this.relayDoc.getMap('tables');
-            // Get or create table map
-            let tableMap = tablesMap.get(tableName);
-            if (!tableMap) {
-                tableMap = new Y.Map();
-                tablesMap.set(tableName, tableMap);
-            }
-            if (operation === 'delete') {
-                tableMap.delete(rowId);
-            }
-            else {
-                tableMap.set(rowId, { ...data, _syncedAt: Date.now() });
-            }
-        }
-        catch (err) {
-            console.warn('[Dash] Failed to broadcast to relay:', err);
-        }
-    }
-    /**
-     * 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 (D1 and Relay)
-     */
-    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
-            }
-        }
-        // Get Relay status
-        let relayConnected = false;
-        let relayRoomName = null;
-        let relayPeerCount = 0;
-        if (this.relayProvider) {
-            try {
-                const status = this.relayProvider.getConnectionStatus();
-                relayConnected = status.connected;
-                relayRoomName = status.roomName;
-                relayPeerCount = this.relayProvider.getPeerCount();
-            }
-            catch {
-                // Provider might not be ready
-            }
-        }
-        return {
-            enabled: this.cloudSyncEnabled || this.relaySyncEnabled,
-            syncing: this.isCloudSyncing,
-            lastSyncTime: this.lastCloudSyncTime,
-            pendingChanges,
-            syncedTables: Array.from(this.syncedTables),
-            d1: {
-                enabled: this.cloudSyncEnabled,
-                syncing: this.isCloudSyncing,
-                lastSyncTime: this.lastCloudSyncTime,
-                pendingChanges,
-            },
-            relay: {
-                enabled: this.relaySyncEnabled,
-                connected: relayConnected,
-                roomName: relayRoomName,
-                peerCount: relayPeerCount,
-            },
-        };
-    }
-    /**
-     * Disable cloud sync (both D1 and Relay)
-     */
-    disableCloudSync() {
-        this.stopCloudSync();
-        this.stopRelaySync();
-        try {
-            this.execute("UPDATE dash_sync_meta SET value = '0' WHERE key = 'cloud_enabled'");
-        }
-        catch {
-            // Table might not exist yet
-        }
-        console.log('[Dash] Cloud sync disabled');
-    }
-    // ============================================
-    // INTROSPECTION METHODS FOR DASH-STUDIO
-    // ============================================
-    /**
-     * Get information about all tables in the database
-     */
-    getAllTables() {
-        if (!this.db)
-            return [];
-        const tables = this.execute(`
-      SELECT name, type
-      FROM sqlite_master
-      WHERE type IN ('table', 'virtual table')
-      AND name NOT LIKE 'sqlite_%'
-      ORDER BY name
-    `);
-        return tables.map((t) => {
-            const rowCount = this.getTableRowCount(t.name);
-            return {
-                name: t.name,
-                type: t.type === 'table' ? 'table' : 'virtual',
-                rowCount,
-                isVirtual: t.type !== 'table'
-            };
-        });
-    }
-    /**
-     * Get detailed schema information for a specific table
-     */
-    getTableSchema(tableName) {
-        if (!this.db)
-            return null;
-        try {
-            const columns = this.execute(`PRAGMA table_info('${tableName.replace(/'/g, "''")}')`);
-            // Get indexes for this table
-            const indexes = this.execute(`PRAGMA index_list('${tableName.replace(/'/g, "''")}')`);
-            // Get foreign keys
-            const foreignKeys = this.execute(`PRAGMA foreign_key_list('${tableName.replace(/'/g, "''")}')`);
-            return {
-                name: tableName,
-                columns: columns.map((col) => ({
-                    cid: col.cid,
-                    name: col.name,
-                    type: col.type || 'ANY',
-                    notNull: col.notnull === 1,
-                    defaultValue: col.dflt_value,
-                    isPrimaryKey: col.pk === 1
-                })),
-                indexes: indexes.map((idx) => ({
-                    name: idx.name,
-                    unique: idx.unique === 1,
-                    origin: idx.origin
-                })),
-                foreignKeys: foreignKeys.map((fk) => ({
-                    id: fk.id,
-                    table: fk.table,
-                    from: fk.from,
-                    to: fk.to
-                })),
-                rowCount: this.getTableRowCount(tableName)
-            };
-        }
-        catch (e) {
-            console.warn(`Failed to get schema for table ${tableName}:`, e);
-            return null;
-        }
-    }
-    /**
-     * Get the row count for a specific table
-     */
-    getTableRowCount(tableName) {
-        if (!this.db)
-            return 0;
-        try {
-            const result = this.execute(`SELECT COUNT(*) as count FROM "${tableName.replace(/"/g, '""')}"`);
-            return result[0]?.count ?? 0;
-        }
-        catch (e) {
-            // Virtual tables may not support COUNT
-            return -1;
-        }
-    }
-    /**
-     * Get statistics about the vector index
-     */
-    getVectorIndexStats() {
-        if (!this.db) {
-            return { totalEmbeddings: 0, dimensions: 384, indexExists: false };
-        }
-        try {
-            const countResult = this.execute('SELECT COUNT(*) as count FROM dash_vec_idx');
-            const totalEmbeddings = countResult[0]?.count ?? 0;
-            return {
-                totalEmbeddings,
-                dimensions: 384, // Fixed dimension from schema
-                indexExists: true,
-                tableName: 'dash_vec_idx'
-            };
-        }
-        catch (e) {
-            return {
-                totalEmbeddings: 0,
-                dimensions: 384,
-                indexExists: false,
-                error: e instanceof Error ? e.message : 'Vector index not available'
-            };
-        }
-    }
-    /**
-     * Get all embeddings from the vector index
-     */
-    getAllEmbeddings(limit = 100, offset = 0) {
-        if (!this.db)
-            return [];
-        try {
-            const rows = this.execute(`
-        SELECT v.id, i.content, v.embedding
-        FROM dash_vec_idx v
-        LEFT JOIN dash_items i ON v.id = i.id
-        LIMIT ? OFFSET ?
-      `, [limit, offset]);
-            return rows.map((row) => ({
-                id: row.id,
-                content: row.content,
-                embedding: row.embedding ? Array.from(row.embedding) : null
-            }));
-        }
-        catch (e) {
-            console.warn('Failed to get embeddings:', e);
-            return [];
-        }
-    }
-    /**
-     * Search for similar vectors given a raw vector
-     */
-    searchSimilarByVector(vector, k = 5) {
-        if (!this.db)
-            return [];
-        try {
-            const rows = this.execute(`
-        SELECT
-          item.id,
-          item.content,
-          distance
-        FROM dash_vec_idx
-        JOIN dash_items AS item ON item.id = dash_vec_idx.id
-        WHERE embedding MATCH ?
-        ORDER BY distance
-        LIMIT ?
-      `, [new Float32Array(vector), k]);
-            return rows.map((row) => ({
-                id: row.id,
-                content: row.content,
-                distance: row.distance,
-                score: row.distance !== undefined ? 1 - row.distance : 0
-            }));
-        }
-        catch (e) {
-            console.warn('Vector search failed:', e);
-            return [];
-        }
-    }
-    /**
-     * Get statistics about the spatial R-Tree index
-     */
-    getSpatialIndexStats() {
-        if (!this.db) {
-            return { totalEntries: 0, indexExists: false };
-        }
-        try {
-            const countResult = this.execute('SELECT COUNT(*) as count FROM dash_spatial_idx');
-            const totalEntries = countResult[0]?.count ?? 0;
-            // Get bounding box of all entries
-            const boundsResult = this.execute(`
-        SELECT
-          MIN(minX) as minX, MAX(maxX) as maxX,
-          MIN(minY) as minY, MAX(maxY) as maxY,
-          MIN(minZ) as minZ, MAX(maxZ) as maxZ
-        FROM dash_spatial_idx
-      `);
-            const bounds = boundsResult[0] || {};
-            return {
-                totalEntries,
-                indexExists: true,
-                tableName: 'dash_spatial_idx',
-                globalBounds: totalEntries > 0 ? {
-                    minX: bounds.minX,
-                    maxX: bounds.maxX,
-                    minY: bounds.minY,
-                    maxY: bounds.maxY,
-                    minZ: bounds.minZ,
-                    maxZ: bounds.maxZ
-                } : undefined
-            };
-        }
-        catch (e) {
-            return {
-                totalEntries: 0,
-                indexExists: false,
-                error: e instanceof Error ? e.message : 'Spatial index not available'
-            };
-        }
-    }
-    /**
-     * Get all spatial bounds from the R-Tree index
-     */
-    getAllSpatialBounds(limit = 100, offset = 0) {
-        if (!this.db)
-            return [];
-        try {
-            const rows = this.execute(`
-        SELECT
-          idx.id as rowid,
-          map.item_id as id,
-          idx.minX, idx.maxX,
-          idx.minY, idx.maxY,
-          idx.minZ, idx.maxZ,
-          item.content
-        FROM dash_spatial_idx idx
-        JOIN dash_spatial_map map ON map.rowid = idx.id
-        LEFT JOIN dash_items item ON item.id = map.item_id
-        LIMIT ? OFFSET ?
-      `, [limit, offset]);
-            return rows.map((row) => ({
-                id: row.id,
-                rowid: row.rowid,
-                bounds: {
-                    minX: row.minX,
-                    maxX: row.maxX,
-                    minY: row.minY,
-                    maxY: row.maxY,
-                    minZ: row.minZ,
-                    maxZ: row.maxZ
-                },
-                content: row.content
-            }));
-        }
-        catch (e) {
-            console.warn('Failed to get spatial bounds:', e);
-            return [];
-        }
-    }
-    /**
-     * Get information about active table subscriptions
-     */
-    getActiveSubscriptions() {
-        const subscriptions = [];
-        this.tableListeners.forEach((listeners, tableName) => {
-            subscriptions.push({
-                table: tableName,
-                listenerCount: listeners.size
-            });
-        });
-        // Add global listeners
-        if (this.listeners.size > 0) {
-            subscriptions.push({
-                table: '*',
-                listenerCount: this.listeners.size
-            });
-        }
-        return subscriptions;
-    }
-    /**
-     * Get table listener counts as a map
-     */
-    getTableListenerCounts() {
-        const counts = {};
-        this.tableListeners.forEach((listeners, tableName) => {
-            counts[tableName] = listeners.size;
-        });
-        counts['*'] = this.listeners.size;
-        return counts;
-    }
-    /**
-     * Check if the database is ready
-     */
-    isReady() {
-        return this.db !== null;
-    }
-    /**
-     * Get database metadata
-     */
-    getDatabaseInfo() {
-        if (!this.db) {
-            return {
-                ready: false,
-                schemaVersion: this.currentSchemaVersion,
-                tableCount: 0
-            };
-        }
-        const tables = this.getAllTables();
-        return {
-            ready: true,
-            schemaVersion: this.currentSchemaVersion,
-            tableCount: tables.length,
-            tables: tables.map(t => t.name)
-        };
-    }
-}
-export const dash = new DashEngine();