local-lite 0.0.4 → 0.0.5

package/dist/core/query-builder.js

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = void 0;
+exports.formatColumnIdentifier = formatColumnIdentifier;
+/**
+ * Escapes an identifier or compound identifier (e.g. 'table.column' or 'table.col as alias').
+ */
+function formatColumnIdentifier(col) {
+    const trimmed = col.trim();
+    if (trimmed === '*')
+        return '*';
+    // Handle "expression AS alias"
+    const asMatch = trimmed.match(/^(.+?)\s+(?:AS|as)\s+([A-Za-z0-9_"]+)$/i);
+    if (asMatch) {
+        const [, expr, rawAlias] = asMatch;
+        const unquotedAlias = rawAlias.startsWith('"') && rawAlias.endsWith('"')
+            ? rawAlias.slice(1, -1)
+            : rawAlias;
+        const cleanAlias = `"${unquotedAlias.replace(/"/g, '""')}"`;
+        if (expr.includes('(') && expr.endsWith(')')) {
+            return `${expr} AS ${cleanAlias}`;
+        }
+        return `${formatColumnIdentifier(expr)} AS ${cleanAlias}`;
+    }
+    // Handle function calls without alias (e.g. COUNT(*))
+    if (trimmed.includes('(') && trimmed.endsWith(')')) {
+        return trimmed;
+    }
+    // Handle "table.column"
+    if (trimmed.includes('.')) {
+        return trimmed
+            .split('.')
+            .map((part) => `"${part.replace(/"/g, '""')}"`)
+            .join('.');
+    }
+    return `"${trimmed.replace(/"/g, '""')}"`;
+}
+/**
+ * Fluent, type-safe SQL Query Builder for local-first SQLite operations.
+ * Allows writing expressive JavaScript code that compiles and executes high-performance SQL under the hood.
+ */
+class QueryBuilder {
+    client;
+    tableName;
+    selectCols = ['*'];
+    joins = [];
+    whereConditions = {};
+    orderColumn;
+    orderDirection = 'ASC';
+    limitCount;
+    offsetCount;
+    groupByCols = [];
+    includeDeleted = false;
+    constructor(client, tableName) {
+        this.client = client;
+        this.tableName = tableName;
+    }
+    /**
+     * Specifies which columns to select.
+     * Supports column aliases (e.g. ['id', 'contracts.rent_amount AS rent', 'houses.house_number']).
+     */
+    select(...columns) {
+        const flat = columns.flat();
+        if (flat.length > 0) {
+            this.selectCols = flat;
+        }
+        return this;
+    }
+    /**
+     * Inner joins another SQLite table on a matching column expression.
+     */
+    join(table, firstCol, secondCol) {
+        this.joins.push({ type: 'INNER', table, firstCol, secondCol });
+        return this;
+    }
+    /**
+     * Left joins another SQLite table on a matching column expression.
+     */
+    leftJoin(table, firstCol, secondCol) {
+        this.joins.push({ type: 'LEFT', table, firstCol, secondCol });
+        return this;
+    }
+    /**
+     * Adds WHERE criteria to filter results.
+     * Supports:
+     * - where({ status: 'ACTIVE' })
+     * - where('status', 'ACTIVE')
+     * - where('end_date', '>=', today)
+     */
+    where(columnOrFilter, operatorOrValue, value) {
+        if (typeof columnOrFilter === 'string') {
+            if (value !== undefined) {
+                const rawOp = String(operatorOrValue).toLowerCase().trim();
+                const opKey = rawOp === '>=' ? '$gte' :
+                    rawOp === '<=' ? '$lte' :
+                        rawOp === '>' ? '$gt' :
+                            rawOp === '<' ? '$lt' :
+                                rawOp === '!=' || rawOp === '<>' ? '$ne' :
+                                    rawOp === '=' || rawOp === '==' ? '$eq' :
+                                        rawOp === 'like' ? '$contains' : '$eq';
+                const existing = typeof this.whereConditions[columnOrFilter] === 'object' &&
+                    this.whereConditions[columnOrFilter] !== null
+                    ? this.whereConditions[columnOrFilter]
+                    : {};
+                this.whereConditions[columnOrFilter] = { ...existing, [opKey]: value };
+            }
+            else {
+                this.whereConditions[columnOrFilter] = operatorOrValue;
+            }
+        }
+        else if (columnOrFilter && typeof columnOrFilter === 'object') {
+            this.whereConditions = { ...this.whereConditions, ...columnOrFilter };
+        }
+        return this;
+    }
+    /**
+     * Orders query results by column and direction.
+     */
+    orderBy(column, direction = 'ASC') {
+        this.orderColumn = column;
+        this.orderDirection = direction.toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
+        return this;
+    }
+    /**
+     * Groups rows by one or more columns for aggregation.
+     */
+    groupBy(...columns) {
+        this.groupByCols = columns.flat();
+        return this;
+    }
+    /**
+     * Limits the number of returned records.
+     */
+    limit(count) {
+        this.limitCount = count;
+        return this;
+    }
+    /**
+     * Offsets the starting record position.
+     */
+    offset(count) {
+        this.offsetCount = count;
+        return this;
+    }
+    /**
+     * Includes soft-deleted rows in results.
+     */
+    withDeleted(include = true) {
+        this.includeDeleted = include;
+        return this;
+    }
+    /**
+     * Applies standard QueryOptions (select, where, orderBy, limit, offset, includeDeleted) to this query.
+     */
+    applyOptions(options) {
+        if (!options)
+            return this;
+        if (options.select)
+            this.select(options.select);
+        if (options.where && typeof options.where === 'object')
+            this.where(options.where);
+        if (options.orderBy)
+            this.orderBy(options.orderBy, options.order || 'ASC');
+        if (typeof options.limit === 'number')
+            this.limit(options.limit);
+        if (typeof options.offset === 'number')
+            this.offset(options.offset);
+        if (options.includeDeleted)
+            this.withDeleted(true);
+        return this;
+    }
+    /**
+     * Compiles the current builder state into an executable SQL string and parameter list.
+     */
+    toSQL() {
+        const params = [];
+        const projections = this.selectCols.map(formatColumnIdentifier).join(', ');
+        const fromTable = `"${this.tableName.replace(/"/g, '""')}"`;
+        let sql = `SELECT ${projections} FROM ${fromTable}`;
+        // Append JOINs
+        for (const j of this.joins) {
+            const joinTable = `"${j.table.replace(/"/g, '""')}"`;
+            const col1 = formatColumnIdentifier(j.firstCol);
+            const col2 = formatColumnIdentifier(j.secondCol);
+            sql += ` ${j.type} JOIN ${joinTable} ON ${col1} = ${col2}`;
+        }
+        // Build WHERE clauses
+        const whereClauses = [];
+        if (this.whereConditions && typeof this.whereConditions === 'object') {
+            for (const [col, val] of Object.entries(this.whereConditions)) {
+                if (col === '$or' || col === '$and')
+                    continue;
+                const safeCol = formatColumnIdentifier(col);
+                if (val === null) {
+                    whereClauses.push(`${safeCol} IS NULL`);
+                }
+                else if (typeof val === 'boolean') {
+                    whereClauses.push(`${safeCol} = ?`);
+                    params.push(val ? 1 : 0);
+                }
+                else if (typeof val === 'string' || typeof val === 'number') {
+                    whereClauses.push(`${safeCol} = ?`);
+                    params.push(val);
+                }
+                else if (typeof val === 'object' && !Array.isArray(val)) {
+                    const ops = val;
+                    const eqVal = ops.$eq !== undefined ? ops.$eq : ops.eq;
+                    if (eqVal !== undefined) {
+                        whereClauses.push(`${safeCol} = ?`);
+                        params.push(typeof eqVal === 'boolean' ? (eqVal ? 1 : 0) : eqVal);
+                    }
+                    const neVal = ops.$ne !== undefined ? ops.$ne : ops.ne;
+                    if (neVal !== undefined) {
+                        whereClauses.push(`${safeCol} != ?`);
+                        params.push(typeof neVal === 'boolean' ? (neVal ? 1 : 0) : neVal);
+                    }
+                    const gtVal = ops.$gt !== undefined ? ops.$gt : ops.gt;
+                    if (gtVal !== undefined) {
+                        whereClauses.push(`${safeCol} > ?`);
+                        params.push(gtVal);
+                    }
+                    const gteVal = ops.$gte !== undefined ? ops.$gte : ops.gte;
+                    if (gteVal !== undefined) {
+                        whereClauses.push(`${safeCol} >= ?`);
+                        params.push(gteVal);
+                    }
+                    const ltVal = ops.$lt !== undefined ? ops.$lt : ops.lt;
+                    if (ltVal !== undefined) {
+                        whereClauses.push(`${safeCol} < ?`);
+                        params.push(ltVal);
+                    }
+                    const lteVal = ops.$lte !== undefined ? ops.$lte : ops.lte;
+                    if (lteVal !== undefined) {
+                        whereClauses.push(`${safeCol} <= ?`);
+                        params.push(lteVal);
+                    }
+                    const inVal = ops.$in !== undefined ? ops.$in : ops.in;
+                    if (Array.isArray(inVal) && inVal.length > 0) {
+                        const placeholders = inVal.map(() => '?').join(', ');
+                        whereClauses.push(`${safeCol} IN (${placeholders})`);
+                        params.push(...inVal);
+                    }
+                    const ninVal = ops.$nin !== undefined ? ops.$nin : ops.nin;
+                    if (Array.isArray(ninVal) && ninVal.length > 0) {
+                        const placeholders = ninVal.map(() => '?').join(', ');
+                        whereClauses.push(`${safeCol} NOT IN (${placeholders})`);
+                        params.push(...ninVal);
+                    }
+                    const containsVal = ops.$contains !== undefined ? ops.$contains : ops.contains;
+                    if (containsVal !== undefined) {
+                        whereClauses.push(`${safeCol} LIKE ?`);
+                        params.push(`%${containsVal}%`);
+                    }
+                    const nullVal = ops.$null !== undefined ? ops.$null : ops.null;
+                    if (nullVal !== undefined) {
+                        whereClauses.push(nullVal ? `${safeCol} IS NULL` : `${safeCol} IS NOT NULL`);
+                    }
+                }
+            }
+        }
+        // Push down soft-deletion check on primary table if deleted column exists and not explicitly overridden
+        const schemaManager = 'schemaManager' in this.client
+            ? this.client.schemaManager
+            : this.client.parent?.schemaManager;
+        if (!this.includeDeleted && schemaManager?.hasColumn(this.tableName, 'deleted')) {
+            const delCol = this.tableName.includes('.')
+                ? `${formatColumnIdentifier(this.tableName)}."deleted"`
+                : `"${this.tableName.replace(/"/g, '""')}"."deleted"`;
+            whereClauses.push(`(${delCol} IS NULL OR (${delCol} != 1 AND ${delCol} != 'true'))`);
+        }
+        if (whereClauses.length > 0) {
+            sql += ` WHERE ${whereClauses.join(' AND ')}`;
+        }
+        // GROUP BY
+        if (this.groupByCols.length > 0) {
+            sql += ` GROUP BY ${this.groupByCols.map(formatColumnIdentifier).join(', ')}`;
+        }
+        // ORDER BY
+        if (this.orderColumn) {
+            sql += ` ORDER BY ${formatColumnIdentifier(this.orderColumn)} ${this.orderDirection}`;
+        }
+        // LIMIT & OFFSET
+        if (typeof this.limitCount === 'number' && this.limitCount > 0) {
+            sql += ` LIMIT ?`;
+            params.push(this.limitCount);
+            if (typeof this.offsetCount === 'number' && this.offsetCount > 0) {
+                sql += ` OFFSET ?`;
+                params.push(this.offsetCount);
+            }
+        }
+        return { sql, params };
+    }
+    /**
+     * Executes the compiled SQL query against SQLite and returns rows.
+     */
+    async execute() {
+        const schemaManager = 'schemaManager' in this.client
+            ? this.client.schemaManager
+            : this.client.parent?.schemaManager;
+        const db = 'db' in this.client ? this.client.db : this.client.tx;
+        if (schemaManager && db) {
+            await schemaManager.ensureTableIntrospected(db, this.tableName);
+            for (const j of this.joins) {
+                await schemaManager.ensureTableIntrospected(db, j.table);
+            }
+        }
+        const { sql, params } = this.toSQL();
+        try {
+            const rawRows = await this.client.query(sql, params);
+            const hydrator = 'hydrateRow' in this.client
+                ? this.client.hydrateRow.bind(this.client)
+                : this.client.parent?.hydrateRow?.bind(this.client.parent);
+            if (hydrator && rawRows && rawRows.length > 0) {
+                return rawRows.map((r) => hydrator(this.tableName, r));
+            }
+            return rawRows;
+        }
+        catch (err) {
+            const msg = String(err?.message || err || '');
+            if (msg.includes('no such table') || msg.includes('no such column')) {
+                return [];
+            }
+            throw err;
+        }
+    }
+    /**
+     * Returns the first matching record or null if not found.
+     */
+    async first() {
+        const originalLimit = this.limitCount;
+        this.limitCount = 1;
+        const rows = await this.execute();
+        this.limitCount = originalLimit;
+        return rows.length > 0 ? rows[0] : null;
+    }
+    /**
+     * Executes a COUNT(*) in SQLite and returns the numeric count directly.
+     */
+    async count() {
+        const originalSelect = this.selectCols;
+        this.selectCols = ['COUNT(*) AS _count'];
+        const rows = await this.execute();
+        this.selectCols = originalSelect;
+        const countVal = rows[0]?._count;
+        return typeof countVal === 'number' ? countVal : Number(countVal) || 0;
+    }
+    /**
+     * Executes a SUM(column) in SQLite and returns the numeric total directly.
+     */
+    async sum(column) {
+        const originalSelect = this.selectCols;
+        const safeCol = formatColumnIdentifier(column);
+        this.selectCols = [`COALESCE(SUM(${safeCol}), 0) AS _sum`];
+        const rows = await this.execute();
+        this.selectCols = originalSelect;
+        const sumVal = rows[0]?._sum;
+        return typeof sumVal === 'number' ? sumVal : Number(sumVal) || 0;
+    }
+    /**
+     * Executes an AVG(column) in SQLite and returns the average directly.
+     */
+    async avg(column) {
+        const originalSelect = this.selectCols;
+        const safeCol = formatColumnIdentifier(column);
+        this.selectCols = [`AVG(${safeCol}) AS _avg`];
+        const rows = await this.execute();
+        this.selectCols = originalSelect;
+        const avgVal = rows[0]?._avg;
+        return avgVal === null || avgVal === undefined ? null : Number(avgVal) || 0;
+    }
+}
+exports.QueryBuilder = QueryBuilder;

package/dist/core/schema-manager.js

@@ -91,6 +91,38 @@ class SchemaManager {
                     }
                 }
             }
+            // Auto-create high performance single and composite indexes for foreign keys (_id) and soft-deletes (deleted)
+            const hasDeleted = this.knownColumns.has(`${tableName}:deleted`);
+            for (const entry of this.knownColumns) {
+                if (!entry.startsWith(`${tableName}:`))
+                    continue;
+                const colName = entry.slice(tableName.length + 1);
+                if (colName.endsWith('_id') && colName !== 'id') {
+                    const fkIndexKey = `${tableName}:${colName}`;
+                    if (!this.knownIndexes.has(fkIndexKey)) {
+                        this.knownIndexes.add(fkIndexKey);
+                        try {
+                            const idxName = (0, sql_js_1.escapeIdentifier)(`idx_${tableName}_${colName}`);
+                            const safeFk = (0, sql_js_1.escapeIdentifier)(colName);
+                            await db.execute(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${safeTable} (${safeFk});`);
+                        }
+                        catch { }
+                    }
+                    if (hasDeleted) {
+                        const compositeKey = `${tableName}:${colName}_deleted`;
+                        if (!this.knownIndexes.has(compositeKey)) {
+                            this.knownIndexes.add(compositeKey);
+                            try {
+                                const idxName = (0, sql_js_1.escapeIdentifier)(`idx_${tableName}_${colName}_del`);
+                                const safeFk = (0, sql_js_1.escapeIdentifier)(colName);
+                                const safeDel = (0, sql_js_1.escapeIdentifier)('deleted');
+                                await db.execute(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${safeTable} (${safeFk}, ${safeDel});`);
+                            }
+                            catch { }
+                        }
+                    }
+                }
+            }
         }
         catch {
             // Ignore
@@ -171,10 +203,9 @@ class SchemaManager {
                 // Auto-index foreign keys and common query columns
                 const lowerKey = key.toLowerCase();
                 if (lowerKey.endsWith('_id') ||
-                    lowerKey === 'business_id' ||
                     lowerKey === 'deleted' ||
                     lowerKey === 'created_at' ||
-                    lowerKey === 'payment_date') {
+                    lowerKey === 'updated_at') {
                     const indexKey = `${tableName}:${lowerKey}`;
                     if (!this.knownIndexes.has(indexKey)) {
                         this.knownIndexes.add(indexKey);
@@ -190,20 +221,24 @@ class SchemaManager {
                 }
             }
         }
-        // Auto-create high performance composite index for multi-tenant soft-deleted queries
-        if (this.knownColumns.has(`${tableName}:business_id`) &&
-            this.knownColumns.has(`${tableName}:deleted`)) {
-            const compositeKey = `${tableName}:business_id_deleted`;
-            if (!this.knownIndexes.has(compositeKey)) {
-                this.knownIndexes.add(compositeKey);
-                try {
-                    const idxName = (0, sql_js_1.escapeIdentifier)(`idx_${tableName}_biz_del`);
-                    const safeBiz = (0, sql_js_1.escapeIdentifier)('business_id');
-                    const safeDel = (0, sql_js_1.escapeIdentifier)('deleted');
-                    await db.execute(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${safeTable} (${safeBiz}, ${safeDel});`);
-                }
-                catch {
-                    // Ignore
+        // Auto-create high performance composite index for foreign keys with soft-deletion
+        if (this.knownColumns.has(`${tableName}:deleted`)) {
+            for (const key of keys) {
+                const lowerKey = key.toLowerCase();
+                if (lowerKey.endsWith('_id') && lowerKey !== 'id') {
+                    const compositeKey = `${tableName}:${lowerKey}_deleted`;
+                    if (!this.knownIndexes.has(compositeKey)) {
+                        this.knownIndexes.add(compositeKey);
+                        try {
+                            const idxName = (0, sql_js_1.escapeIdentifier)(`idx_${tableName}_${lowerKey}_del`);
+                            const safeFk = (0, sql_js_1.escapeIdentifier)(key);
+                            const safeDel = (0, sql_js_1.escapeIdentifier)('deleted');
+                            await db.execute(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${safeTable} (${safeFk}, ${safeDel});`);
+                        }
+                        catch {
+                            // Ignore
+                        }
+                    }
                 }
             }
         }

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export * from './core/outbox-store.js';
 export * from './core/meta-store.js';
 export * from './core/table-manager.js';
 export * from './core/schema-manager.js';
+export * from './core/query-builder.js';
 export * from './reactive/event-emitter.js';
 export * from './adapters/local/index.js';
 export * from './adapters/remote/index.js';
@@ -16,3 +17,4 @@ export type * from './react/index.js';
 export * from './utils/uuid.js';
 export * from './utils/sql.js';
 export * from './utils/logger.js';
+export * from './schema/index.js';

package/dist/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./core/outbox-store.js"), exports);
 __exportStar(require("./core/meta-store.js"), exports);
 __exportStar(require("./core/table-manager.js"), exports);
 __exportStar(require("./core/schema-manager.js"), exports);
+__exportStar(require("./core/query-builder.js"), exports);
 __exportStar(require("./reactive/event-emitter.js"), exports);
 __exportStar(require("./adapters/local/index.js"), exports);
 __exportStar(require("./adapters/remote/index.js"), exports);
@@ -31,3 +32,4 @@ __exportStar(require("./config/index.js"), exports);
 __exportStar(require("./utils/uuid.js"), exports);
 __exportStar(require("./utils/sql.js"), exports);
 __exportStar(require("./utils/logger.js"), exports);
+__exportStar(require("./schema/index.js"), exports);

package/dist/react/SyncInspector.js

@@ -92,37 +92,6 @@ function SyncInspector({ client, position = 'bottom-right', variant = 'pill', in
             numColor: metrics?.outboxFailedCount ? '#EF4444' : '#10B981',
         },
     ], [status.pendingCount, metrics?.outboxFailedCount, currentTheme.text]);
-    // Shared Connection & Telemetry Rows
-    const telemetryItems = (0, react_1.useMemo)(() => [
-        {
-            id: 'status',
-            label: 'Connection Status',
-            value: status.isOnline ? 'Online (Connected)' : 'Offline',
-            color: statusColor,
-            hasDot: true,
-        },
-        {
-            id: 'sync-state',
-            label: 'Sync State',
-            value: status.isSyncing ? 'Syncing...' : 'Idle',
-            color: status.isSyncing ? '#F59E0B' : currentTheme.textMuted,
-        },
-        {
-            id: 'last-synced',
-            label: 'Last Synchronized',
-            value: status.lastSyncedAt ? new Date(status.lastSyncedAt).toLocaleTimeString() : 'Never',
-        },
-        {
-            id: 'push-duration',
-            label: 'Last Push Duration',
-            value: `${metrics?.lastPushDurationMs || 0} ms`,
-        },
-        {
-            id: 'pull-duration',
-            label: 'Last Pull Duration',
-            value: `${metrics?.lastPullDurationMs || 0} ms`,
-        },
-    ], [status.isOnline, status.isSyncing, status.lastSyncedAt, statusColor, metrics?.lastPushDurationMs, metrics?.lastPullDurationMs, currentTheme.textMuted]);
     // Shared Action Buttons
     const actionButtons = (0, react_1.useMemo)(() => [
         { id: 'push', label: '🚀 Push Changes', onPress: handlePush, bg: '#3B82F6', color: '#FFFFFF' },
@@ -185,19 +154,6 @@ function SyncInspector({ client, position = 'bottom-right', variant = 'pill', in
                                                 backgroundColor: currentTheme.card,
                                                 borderColor: currentTheme.border,
                                             },
-                                        ], children: [(0, jsx_runtime_1.jsx)(Text, { style: [rnStyles.infoCardTitle, { color: currentTheme.textMuted }], children: "CONNECTION & TELEMETRY" }), telemetryItems.map((item, idx) => ((0, jsx_runtime_1.jsxs)(View, { style: [
-                                                    rnStyles.infoRow,
-                                                    { borderBottomColor: currentTheme.border },
-                                                    idx === telemetryItems.length - 1 && { borderBottomWidth: 0 },
-                                                ], children: [(0, jsx_runtime_1.jsx)(Text, { style: [rnStyles.infoKey, { color: currentTheme.textMuted }], children: item.label }), (0, jsx_runtime_1.jsxs)(View, { style: { flexDirection: 'row', alignItems: 'center', gap: 6 }, children: [item.hasDot && (0, jsx_runtime_1.jsx)(View, { style: [rnStyles.dotSmall, { backgroundColor: item.color }] }), (0, jsx_runtime_1.jsx)(Text, { style: [
-                                                                    rnStyles.infoVal,
-                                                                    item.color ? { color: item.color, fontWeight: '700' } : { color: currentTheme.text },
-                                                                ], children: item.value })] })] }, item.id)))] }), (0, jsx_runtime_1.jsxs)(View, { style: [
-                                            rnStyles.infoCard,
-                                            {
-                                                backgroundColor: currentTheme.card,
-                                                borderColor: currentTheme.border,
-                                            },
                                         ], children: [(0, jsx_runtime_1.jsx)(Text, { style: [rnStyles.infoCardTitle, { color: currentTheme.textMuted }], children: "ENGINE ACTIONS" }), (0, jsx_runtime_1.jsx)(View, { style: rnStyles.btnRow, children: actionButtons.slice(0, 2).map((btn) => ((0, jsx_runtime_1.jsx)(TouchableOpacity, { onPress: btn.onPress, style: [rnStyles.actionBtn, { backgroundColor: btn.bg }], activeOpacity: 0.8, children: (0, jsx_runtime_1.jsx)(Text, { style: [rnStyles.actionBtnText, { color: btn.color }], children: btn.label }) }, btn.id))) }), (0, jsx_runtime_1.jsx)(View, { style: [rnStyles.btnRow, { marginTop: 8 }], children: actionButtons.slice(2, 4).map((btn) => ((0, jsx_runtime_1.jsx)(TouchableOpacity, { onPress: btn.onPress, style: [rnStyles.actionBtn, { backgroundColor: btn.bg }], activeOpacity: 0.8, children: (0, jsx_runtime_1.jsx)(Text, { style: [rnStyles.actionBtnText, { color: btn.color }], children: btn.label }) }, btn.id))) })] }), (metrics?.lastPushError || metrics?.lastPullError) && ((0, jsx_runtime_1.jsxs)(View, { style: [rnStyles.infoCard, { borderColor: '#EF444480', backgroundColor: '#7F1D1D20' }], children: [(0, jsx_runtime_1.jsx)(Text, { style: [rnStyles.infoCardTitle, { color: '#F87171' }], children: "SYNC ENGINE ERRORS" }), metrics?.lastPushError && ((0, jsx_runtime_1.jsxs)(View, { style: { marginBottom: 6 }, children: [(0, jsx_runtime_1.jsx)(Text, { style: { fontSize: 11, color: '#FCA5A5', fontWeight: '700' }, children: "Last Push Error:" }), (0, jsx_runtime_1.jsx)(Text, { style: { fontSize: 12, color: '#FECACA' }, children: String(metrics.lastPushError) })] })), metrics?.lastPullError && ((0, jsx_runtime_1.jsxs)(View, { children: [(0, jsx_runtime_1.jsx)(Text, { style: { fontSize: 11, color: '#FCA5A5', fontWeight: '700' }, children: "Last Pull Error:" }), (0, jsx_runtime_1.jsx)(Text, { style: { fontSize: 12, color: '#FECACA' }, children: String(metrics.lastPullError) })] }))] })), status.pendingRecords && status.pendingRecords.length > 0 && ((0, jsx_runtime_1.jsxs)(View, { style: [
                                             rnStyles.infoCard,
                                             {
@@ -324,32 +280,6 @@ function SyncInspector({ client, position = 'bottom-right', variant = 'pill', in
                                     border: `1px solid ${currentTheme.border}`,
                                     borderRadius: 12,
                                     padding: 16,
-                                }, children: [(0, jsx_runtime_1.jsx)("div", { style: {
-                                            fontSize: 11,
-                                            fontWeight: 700,
-                                            color: currentTheme.textMuted,
-                                            letterSpacing: '0.8px',
-                                            marginBottom: 12,
-                                        }, children: "CONNECTION & TELEMETRY" }), telemetryItems.map((item, idx) => ((0, jsx_runtime_1.jsxs)("div", { style: {
-                                            display: 'flex',
-                                            justifyContent: 'space-between',
-                                            alignItems: 'center',
-                                            padding: '8px 0',
-                                            borderBottom: idx === telemetryItems.length - 1 ? 'none' : `1px solid ${currentTheme.border}`,
-                                        }, children: [(0, jsx_runtime_1.jsx)("span", { style: { color: currentTheme.textMuted, fontSize: 13 }, children: item.label }), (0, jsx_runtime_1.jsxs)("div", { style: { display: 'flex', alignItems: 'center', gap: 6 }, children: [item.hasDot && ((0, jsx_runtime_1.jsx)("span", { style: {
-                                                            width: 8,
-                                                            height: 8,
-                                                            borderRadius: 4,
-                                                            backgroundColor: item.color,
-                                                        } })), (0, jsx_runtime_1.jsx)("span", { style: {
-                                                            color: item.color || currentTheme.text,
-                                                            fontSize: 13,
-                                                            fontWeight: item.color ? 700 : 600,
-                                                        }, children: item.value })] })] }, item.id)))] }), (0, jsx_runtime_1.jsxs)("div", { style: {
-                                    backgroundColor: currentTheme.card,
-                                    border: `1px solid ${currentTheme.border}`,
-                                    borderRadius: 12,
-                                    padding: 16,
                                 }, children: [(0, jsx_runtime_1.jsx)("div", { style: {
                                             fontSize: 11,
                                             fontWeight: 700,

package/dist/react/index.d.ts

@@ -28,6 +28,45 @@ export declare function useLiveQuery<T = any>(client: LocalFirstClient | null |
     refetch: () => Promise<void>;
     loading: boolean;
 };
+export type MultiQuerySpec<T = any> = string | (QueryOptions & {
+    table?: string;
+}) | LiveQueryFn<T>;
+export type MultiQueryInput = Array<string | (QueryOptions & {
+    table: string;
+})> | Record<string, MultiQuerySpec>;
+export interface UseLiveQueriesResult<T extends Record<string, any[]>> {
+    data: T;
+    loading: boolean;
+    refetch: () => Promise<void>;
+}
+/**
+ * Reactive multi-table live query hook that loads data from multiple tables concurrently.
+ *
+ * Benefits:
+ * - Parallel fetching: queries SQLite tables concurrently via Promise.all.
+ * - Single atomic React commit: coalesces multiple table results into a single state update,
+ *   preventing cascading re-renders and UI freezing.
+ * - Multi-table event coordination: listens to mutations across all requested tables,
+ *   coalescing updates so downstream calculations only run once.
+ * - Zero-latency cache read-through: returns instant cached rows on mount.
+ *
+ * Usage with dictionary:
+ * ```ts
+ * const { data, loading } = useLiveQueries(client, {
+ *   projects: 'projects',
+ *   tasks: { where: { project_id: '123' }, orderBy: 'created_at' },
+ *   tags: { table: 'labels' }
+ * });
+ * // data.projects, data.tasks, data.tags
+ * ```
+ *
+ * Usage with array:
+ * ```ts
+ * const { data, loading } = useLiveQueries(client, ['projects', 'tasks', 'tags']);
+ * // data.projects, data.tasks, data.tags
+ * ```
+ */
+export declare function useLiveQueries<T extends Record<string, any[]> = Record<string, any[]>>(client: LocalFirstClient | null | undefined, queries: MultiQueryInput): UseLiveQueriesResult<T>;
 /**
  * Reactive hook to query a single record by primary key with 0ms cache read-through.
  * Automatically re-renders only when this specific row or table changes.