local-lite 0.0.3 → 0.0.5

package/dist/core/client.js

@@ -10,6 +10,7 @@ const schema_manager_js_1 = require("./schema-manager.js");
 const uuid_js_1 = require("../utils/uuid.js");
 const sql_js_1 = require("../utils/sql.js");
 const query_js_1 = require("./query.js");
+const query_builder_js_1 = require("./query-builder.js");
 class TransactionalClient {
     parent;
     tx;
@@ -23,22 +24,16 @@ class TransactionalClient {
     }
     async mutate(tableName, rowId, operation, payload, options = {}) {
         const pk = options.primaryKey ?? this.parent.getPrimaryKey();
-        const outboxId = (0, uuid_js_1.generateUUID)();
         const timestamp = options.customTimestamp ?? Date.now();
         await table_manager_js_1.TableManager.applyMutation(this.tx, tableName, rowId, operation, payload, pk, {
             autoSchema: this.parent.autoSchema,
             schemaManager: this.parent.schemaManager,
         });
         if (!options.skipOutbox) {
-            await outbox_store_js_1.OutboxStore.insertRecord(this.tx, {
-                id: outboxId,
-                tableName,
-                rowId,
-                operation,
-                payload,
-                timestamp,
-            });
-            this.queuedOutboxIds.push(outboxId);
+            const outboxId = await this.parent.recordOutboxMutation(this.tx, tableName, rowId, operation, payload, timestamp);
+            if (outboxId) {
+                this.queuedOutboxIds.push(outboxId);
+            }
         }
         this.queuedTableEvents.push({
             tableName,
@@ -70,9 +65,61 @@ class TransactionalClient {
     async update(tableName, rowId, payload, options = {}) {
         await this.mutate(tableName, rowId, 'UPDATE', payload, options);
     }
+    async updateMany(tableName, updates, options = {}) {
+        for (const u of updates) {
+            await this.update(tableName, u.id, u.payload, options);
+        }
+    }
     async delete(tableName, rowId, options = {}) {
         await this.mutate(tableName, rowId, 'DELETE', null, options);
     }
+    async findById(tableName, id, options) {
+        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+        const safePk = (0, sql_js_1.escapeIdentifier)(this.parent.getPrimaryKey());
+        try {
+            const rows = await this.tx.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} = ? LIMIT 1`, [id]);
+            if (!rows || rows.length === 0)
+                return null;
+            const row = this.parent.hydrateRow(tableName, rows[0]);
+            if (!options?.includeDeleted && (0, query_js_1.isDeletedRecord)(row)) {
+                return null;
+            }
+            return row;
+        }
+        catch {
+            return null;
+        }
+    }
+    async findByIds(tableName, ids, options) {
+        if (!ids || ids.length === 0)
+            return [];
+        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+        const safePk = (0, sql_js_1.escapeIdentifier)(this.parent.getPrimaryKey());
+        const placeholders = ids.map(() => '?').join(', ');
+        try {
+            const rows = await this.tx.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} IN (${placeholders})`, ids);
+            if (!rows || rows.length === 0)
+                return [];
+            const hydrated = rows.map((r) => this.parent.hydrateRow(tableName, r));
+            if (!options?.includeDeleted) {
+                return hydrated.filter((r) => !(0, query_js_1.isDeletedRecord)(r));
+            }
+            return hydrated;
+        }
+        catch {
+            return [];
+        }
+    }
+    async findMany(tableName, options) {
+        const rows = await this.from(tableName).applyOptions(options).execute();
+        return (0, query_js_1.applyQueryOptions)(rows, options);
+    }
+    async query(sql, params = []) {
+        return (await this.tx.execute(sql, params));
+    }
+    from(tableName) {
+        return new query_builder_js_1.QueryBuilder(this, tableName);
+    }
     get rawTx() {
         return this.tx;
     }
@@ -85,15 +132,26 @@ class LocalFirstClient {
     syncWorker;
     schemaManager;
     autoSchema;
+    coalesceOutbox;
     tables;
+    jsonColumns;
+    autoHydrateJSON;
     primaryKey;
+    migrations;
+    autoStart;
+    initialization;
     constructor(config) {
         this.db = config.local;
         this.remote = config.remote;
         this.events = new event_emitter_js_1.EventEmitter();
         this.primaryKey = config.primaryKey ?? 'id';
         this.autoSchema = config.autoSchema ?? false;
+        this.coalesceOutbox = config.coalesceOutbox ?? true;
         this.tables = config.tables ?? [];
+        this.migrations = config.migrations ?? [];
+        this.autoStart = config.autoStart ?? true;
+        this.jsonColumns = config.jsonColumns ?? {};
+        this.autoHydrateJSON = config.autoHydrateJSON ?? false;
         this.schemaManager = new schema_manager_js_1.SchemaManager();
         const workerOptions = {
             network: config.network,
@@ -107,26 +165,133 @@ class LocalFirstClient {
             logLevel: config.logLevel,
             autoSchema: this.autoSchema,
             schemaManager: this.schemaManager,
+            autoSync: this.autoStart,
+            syncScope: config.syncScope,
+            autoPauseOnBackground: config.autoPauseOnBackground,
         };
         this.syncWorker = new sync_worker_js_1.SyncWorker(this.db, this.remote, this.events, workerOptions);
     }
     getPrimaryKey() {
         return this.primaryKey;
     }
+    /**
+     * Automatically deserializes JSON string columns into JavaScript objects/arrays.
+     */
+    hydrateRow(tableName, row) {
+        if (!row || typeof row !== 'object')
+            return row;
+        const cols = this.jsonColumns[tableName];
+        if (cols && cols.length > 0) {
+            const copy = { ...row };
+            for (const col of cols) {
+                if (typeof copy[col] === 'string') {
+                    const val = copy[col].trim();
+                    if ((val.startsWith('{') && val.endsWith('}')) || (val.startsWith('[') && val.endsWith(']'))) {
+                        try {
+                            copy[col] = JSON.parse(val);
+                        }
+                        catch {
+                            // keep string if not valid JSON
+                        }
+                    }
+                }
+            }
+            return copy;
+        }
+        if (this.autoHydrateJSON) {
+            const copy = { ...row };
+            for (const [key, val] of Object.entries(copy)) {
+                if (typeof val === 'string') {
+                    const trimmed = val.trim();
+                    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+                        (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+                        try {
+                            copy[key] = JSON.parse(trimmed);
+                        }
+                        catch {
+                            // keep string
+                        }
+                    }
+                }
+            }
+            return copy;
+        }
+        return row;
+    }
+    /**
+     * Writes a mutation to the outbox table, optionally coalescing with existing PENDING records for the same row.
+     * Returns the affected outboxId, or undefined if an offline INSERT was deleted offline before pushing.
+     */
+    async recordOutboxMutation(tx, tableName, rowId, operation, payload, timestamp) {
+        if (this.coalesceOutbox) {
+            const existing = await outbox_store_js_1.OutboxStore.findPendingByRow(tx, tableName, rowId);
+            if (existing && existing.status === 'PENDING') {
+                if (operation === 'DELETE') {
+                    if (existing.operation === 'INSERT') {
+                        // Created offline and deleted offline before ever being pushed to server: clean up outbox completely
+                        await outbox_store_js_1.OutboxStore.deleteRecord(tx, existing.id);
+                        return undefined;
+                    }
+                    else {
+                        await outbox_store_js_1.OutboxStore.updateOperation(tx, existing.id, 'DELETE', null, timestamp);
+                        return existing.id;
+                    }
+                }
+                else if (operation === 'UPDATE') {
+                    const merged = { ...(existing.payload || {}), ...(payload || {}) };
+                    await outbox_store_js_1.OutboxStore.updatePayload(tx, existing.id, merged, timestamp);
+                    return existing.id;
+                }
+                else if (operation === 'INSERT') {
+                    await outbox_store_js_1.OutboxStore.updateOperation(tx, existing.id, 'INSERT', payload, timestamp);
+                    return existing.id;
+                }
+            }
+        }
+        const outboxId = (0, uuid_js_1.generateUUID)();
+        await outbox_store_js_1.OutboxStore.insertRecord(tx, {
+            id: outboxId,
+            tableName,
+            rowId,
+            operation,
+            payload,
+            timestamp,
+        });
+        return outboxId;
+    }
     /**
      * Initializes the client: creates sync_outbox schema, ensures autoSchema tables if enabled,
-     * and starts the background sync worker.
+     * applies migrations, and optionally starts automatic sync. Concurrent/repeated calls
+     * share initialization; failures can be retried. After stop(), explicitly start the worker.
      */
     async initialize() {
+        if (!this.initialization) {
+            this.initialization = this.initializeStorage().catch((error) => {
+                this.initialization = undefined;
+                throw error;
+            });
+        }
+        await this.initialization;
+    }
+    async initializeStorage() {
         await outbox_store_js_1.OutboxStore.ensureSchema(this.db);
         await meta_store_js_1.MetaStore.ensureSchema(this.db);
         await outbox_store_js_1.OutboxStore.resetStaleProcessing(this.db);
+        if (this.migrations.length > 0) {
+            await this.db.transaction(async (tx) => {
+                for (const query of this.migrations) {
+                    if (query.trim())
+                        await tx.execute(query);
+                }
+            });
+        }
         if (this.autoSchema && this.tables.length > 0) {
             for (const table of this.tables) {
                 await this.schemaManager.ensureTable(this.db, table, this.primaryKey);
             }
         }
-        this.syncWorker.start();
+        if (this.autoStart)
+            this.syncWorker.start();
     }
     /**
      * Performs an atomic dual-write: mutates the local data table AND writes
@@ -134,8 +299,8 @@ class LocalFirstClient {
      */
     async mutate(tableName, rowId, operation, payload, options = {}) {
         const pk = options.primaryKey ?? this.primaryKey;
-        const outboxId = (0, uuid_js_1.generateUUID)();
         const timestamp = options.customTimestamp ?? Date.now();
+        let affectedOutboxId;
         const executeInTransaction = async (tx) => {
             // 1. Mutate local table
             await table_manager_js_1.TableManager.applyMutation(tx, tableName, rowId, operation, payload, pk, {
@@ -144,14 +309,7 @@ class LocalFirstClient {
             });
             // 2. Insert into sync_outbox (if not skipped)
             if (!options.skipOutbox) {
-                await outbox_store_js_1.OutboxStore.insertRecord(tx, {
-                    id: outboxId,
-                    tableName,
-                    rowId,
-                    operation,
-                    payload,
-                    timestamp,
-                });
+                affectedOutboxId = await this.recordOutboxMutation(tx, tableName, rowId, operation, payload, timestamp);
             }
         };
         if (options.tx) {
@@ -168,7 +326,10 @@ class LocalFirstClient {
             source: 'local',
         });
         if (!options.skipOutbox) {
-            this.events.emit('sync_outbox', { operation: 'INSERT', rowId: outboxId });
+            this.events.emit('sync_outbox', {
+                operation: affectedOutboxId ? 'INSERT' : 'DELETE',
+                rowId: affectedOutboxId || rowId,
+            });
             // 4. Trigger immediate debounced push
             this.syncWorker.schedulePush(20);
         }
@@ -198,17 +359,11 @@ class LocalFirstClient {
                 });
                 const skipOutbox = m.skipOutbox ?? options.skipOutbox ?? false;
                 if (!skipOutbox) {
-                    const outboxId = (0, uuid_js_1.generateUUID)();
                     const timestamp = m.customTimestamp ?? options.customTimestamp ?? Date.now();
-                    await outbox_store_js_1.OutboxStore.insertRecord(tx, {
-                        id: outboxId,
-                        tableName: m.tableName,
-                        rowId,
-                        operation: m.operation,
-                        payload,
-                        timestamp,
-                    });
-                    queuedOutboxIds.push(outboxId);
+                    const outboxId = await this.recordOutboxMutation(tx, m.tableName, rowId, m.operation, payload, timestamp);
+                    if (outboxId) {
+                        queuedOutboxIds.push(outboxId);
+                    }
                 }
                 queuedEvents.push({
                     tableName: m.tableName,
@@ -309,6 +464,27 @@ class LocalFirstClient {
     async update(tableName, rowId, payload, options = {}) {
         await this.mutate(tableName, rowId, 'UPDATE', payload, options);
     }
+    /**
+     * Updates multiple records atomically in a single database transaction.
+     * Emits reactive change events and queues outbox entries together.
+     *
+     * Example:
+     * await client.updateMany('todos', [
+     *   { id: 'todo-1', payload: { completed: 1 } },
+     *   { id: 'todo-2', payload: { completed: 1 } },
+     * ]);
+     */
+    async updateMany(tableName, updates, options = {}) {
+        if (!updates || updates.length === 0)
+            return;
+        const mutations = updates.map((u) => ({
+            tableName,
+            rowId: u.id,
+            operation: 'UPDATE',
+            payload: u.payload,
+        }));
+        await this.batch(mutations, options);
+    }
     /**
      * Convenience helper to delete a record by ID.
      *
@@ -321,39 +497,201 @@ class LocalFirstClient {
     /**
      * Reads records from a local SQLite table without requiring manual SQL.
      * Supports where filtering with rich operators ($in, $gt, $contains, $or, etc.), order, limit, and offset.
+     * Pushes simple equality where clauses down to SQLite for high performance, with memory fallback.
      * Gracefully returns [] if table or columns have not been populated yet on empty schemas.
      *
+    /**
+     * Executes a raw relational SQL query with parameters directly against SQLite.
+     * Enables complex multi-table JOINs, GROUP BY aggregations (COUNT, SUM, AVG), CTEs, and window functions.
+     */
+    async query(sql, params = []) {
+        return (await this.db.execute(sql, params));
+    }
+    /**
+     * Returns a fluent SQL QueryBuilder for the specified table.
+     * Allows writing clean JavaScript method chains (select, join, leftJoin, where, orderBy, groupBy)
+     * that automatically compile into optimized native SQLite queries.
+     *
+     * Example:
+     * const activeRentals = await client
+     *   .from('contracts')
+     *   .join('houses', 'contracts.house_id', 'houses.id')
+     *   .leftJoin('tenants', 'contracts.tenant_id', 'tenants.id')
+     *   .where({ 'contracts.business_id': bizId, 'contracts.status': 'ACTIVE' })
+     *   .select('contracts.id', 'contracts.rent_amount', 'houses.house_number', 'tenants.name')
+     *   .execute();
+     */
+    from(tableName) {
+        return new query_builder_js_1.QueryBuilder(this, tableName);
+    }
+    /**
+     * Executes a native SQLite COUNT(*) query and returns the count directly.
+     */
+    async count(tableName, options) {
+        const qb = this.from(tableName);
+        if (options?.where)
+            qb.where(options.where);
+        return qb.count();
+    }
+    /**
+     * Executes a native SQLite SUM(column) query and returns the sum directly.
+     */
+    async sum(tableName, column, options) {
+        const qb = this.from(tableName);
+        if (options?.where)
+            qb.where(options.where);
+        return qb.sum(column);
+    }
+    /**
+     * Executes a native SQLite AVG(column) query and returns the average directly.
+     */
+    async avg(tableName, column, options) {
+        const qb = this.from(tableName);
+        if (options?.where)
+            qb.where(options.where);
+        return qb.avg(column);
+    }
+    /**
+     * Executes native multi-metric SQLite aggregation in a single query.
+     *
      * Example:
-     * const tenants = await client.findMany('tenants', { where: { status: 'ACTIVE' }, orderBy: 'name' });
-     * const expensive = await client.findMany('properties', { where: { rent: { $gte: 2000 } } });
+     * const stats = await client.aggregate('receipts', {
+     *   where: { business_id: bizId },
+     *   count: true,
+     *   sum: ['amount', 'refunded_amount'],
+     *   avg: ['amount']
+     * });
      */
+    async aggregate(tableName, spec) {
+        const projections = [];
+        if (spec.count) {
+            projections.push('COUNT(*) AS "_count"');
+        }
+        if (spec.sum) {
+            for (const col of spec.sum) {
+                projections.push(`COALESCE(SUM("${col.replace(/"/g, '""')}"), 0) AS "sum_${col}"`);
+            }
+        }
+        if (spec.avg) {
+            for (const col of spec.avg) {
+                projections.push(`AVG("${col.replace(/"/g, '""')}") AS "avg_${col}"`);
+            }
+        }
+        if (spec.min) {
+            for (const col of spec.min) {
+                projections.push(`MIN("${col.replace(/"/g, '""')}") AS "min_${col}"`);
+            }
+        }
+        if (spec.max) {
+            for (const col of spec.max) {
+                projections.push(`MAX("${col.replace(/"/g, '""')}") AS "max_${col}"`);
+            }
+        }
+        if (projections.length === 0) {
+            return {};
+        }
+        const qb = this.from(tableName).select(...projections);
+        if (spec.where) {
+            qb.where(spec.where);
+        }
+        const rows = await qb.execute();
+        const row = rows[0] || {};
+        const result = {};
+        if (spec.count) {
+            result.count = typeof row._count === 'number' ? row._count : Number(row._count) || 0;
+        }
+        if (spec.sum) {
+            result.sum = {};
+            for (const col of spec.sum) {
+                const val = row[`sum_${col}`];
+                result.sum[col] = typeof val === 'number' ? val : Number(val) || 0;
+            }
+        }
+        if (spec.avg) {
+            result.avg = {};
+            for (const col of spec.avg) {
+                const val = row[`avg_${col}`];
+                result.avg[col] = val === null || val === undefined ? null : Number(val) || 0;
+            }
+        }
+        if (spec.min) {
+            result.min = {};
+            for (const col of spec.min) {
+                result.min[col] = row[`min_${col}`];
+            }
+        }
+        if (spec.max) {
+            result.max = {};
+            for (const col of spec.max) {
+                result.max[col] = row[`max_${col}`];
+            }
+        }
+        return result;
+    }
     async findMany(tableName, options) {
+        const rows = await this.from(tableName).applyOptions(options).execute();
+        return (0, query_js_1.applyQueryOptions)(rows, options);
+    }
+    /**
+     * Finds a single record by primary key.
+     *
+     * Example:
+     * const tenant = await client.findById('tenants', 'ten-1');
+     */
+    async findById(tableName, id, options) {
+        // Primary-key lookup in SQLite instead of loading the whole table into JS.
         const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
-        let rows;
+        const safePk = (0, sql_js_1.escapeIdentifier)(this.primaryKey);
         try {
-            rows = await this.db.execute(`SELECT * FROM ${safeTable}`);
+            const rows = await this.db.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} = ? LIMIT 1`, [id]);
+            if (!rows || rows.length === 0)
+                return null;
+            const row = this.hydrateRow(tableName, rows[0]);
+            if (!options?.includeDeleted && (0, query_js_1.isDeletedRecord)(row)) {
+                return null;
+            }
+            return row;
         }
         catch (err) {
             const msg = String(err?.message || err || '');
             if (msg.includes('no such table') || msg.includes('no such column')) {
-                return [];
+                return null;
             }
             throw err;
         }
-        return (0, query_js_1.applyQueryOptions)(rows, options);
     }
     /**
-     * Finds a single record by primary key.
+     * Finds multiple records by primary keys in a single batched SQL query.
+     * Eliminates the N-roundtrip bridge overhead of multiple findById calls.
+     * Automatically omits soft-deleted records unless includeDeleted: true.
      *
      * Example:
-     * const tenant = await client.findById('tenants', 'ten-1');
+     * const tenants = await client.findByIds('tenants', ['ten-1', 'ten-2', 'ten-3']);
      */
-    async findById(tableName, id) {
-        const results = await this.findMany(tableName, {
-            where: { [this.primaryKey]: id },
-            limit: 1,
-        });
-        return results.length > 0 ? results[0] : null;
+    async findByIds(tableName, ids, options) {
+        if (!ids || ids.length === 0)
+            return [];
+        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+        const safePk = (0, sql_js_1.escapeIdentifier)(this.primaryKey);
+        const placeholders = ids.map(() => '?').join(', ');
+        try {
+            const rows = await this.db.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} IN (${placeholders})`, ids);
+            if (!rows || rows.length === 0)
+                return [];
+            const hasJsonConfig = Boolean(this.jsonColumns[tableName] || this.autoHydrateJSON);
+            const hydrated = hasJsonConfig ? rows.map((r) => this.hydrateRow(tableName, r)) : rows;
+            if (!options?.includeDeleted) {
+                return hydrated.filter((r) => !(0, query_js_1.isDeletedRecord)(r));
+            }
+            return hydrated;
+        }
+        catch (err) {
+            const msg = String(err?.message || err || '');
+            if (msg.includes('no such table') || msg.includes('no such column')) {
+                return [];
+            }
+            throw err;
+        }
     }
     /**
      * Tracks an existing mutation into sync_outbox without modifying the table.
@@ -435,11 +773,58 @@ class LocalFirstClient {
     async resetSyncCursor() {
         await this.syncWorker.resetSyncCursor();
     }
+    /**
+     * Dynamically sets or updates the active sync scope.
+     */
+    setSyncScope(scope) {
+        this.syncWorker.setSyncScope(scope);
+    }
     /**
      * Stops all active intervals, background sync loops, and network listeners.
      */
     stop() {
         this.syncWorker.stop();
     }
+    /**
+     * Stops background sync workers, cleans up remote listeners,
+     * and closes the local database adapter connection (releasing native locks).
+     */
+    async close() {
+        this.stop();
+        if (typeof this.remote.destroy === 'function') {
+            this.remote.destroy();
+        }
+        if (typeof this.db.close === 'function') {
+            await this.db.close();
+        }
+    }
+    /**
+     * Resets local state by stopping sync and deleting or dropping all managed tables,
+     * clearing the sync_outbox and _sync_meta stores, and resetting the sync cursor.
+     */
+    async reset(options = {}) {
+        this.stop();
+        const tablesToReset = Array.from(new Set([...this.tables, 'sync_outbox', 'sync_meta']));
+        for (const table of tablesToReset) {
+            try {
+                if (options.dropTables) {
+                    await this.db.execute(`DROP TABLE IF EXISTS "${table}"`);
+                }
+                else {
+                    await this.db.execute(`DELETE FROM "${table}"`);
+                }
+            }
+            catch {
+                // Table may not exist yet; safe to ignore
+            }
+        }
+        if (options.dropTables) {
+            this.initialization = undefined;
+            // Dropped tables must be re-created by autoSchema on next write.
+            this.schemaManager.clearCache();
+        }
+        await this.resetSyncCursor();
+        this.events.emit('reset', { dropTables: options.dropTables ?? false });
+    }
 }
 exports.LocalFirstClient = LocalFirstClient;

package/dist/core/index.d.ts

@@ -0,0 +1,15 @@
+export * from './client.js';
+export * from './types.js';
+export * from './query.js';
+export * from './sync-worker.js';
+export * from './conflict.js';
+export * from './outbox-store.js';
+export * from './meta-store.js';
+export * from './table-manager.js';
+export * from './schema-manager.js';
+export * from './query-builder.js';
+export * from '../reactive/event-emitter.js';
+export * from '../adapters/network/index.js';
+export type { LocalDBAdapter, LocalTransaction } from '../adapters/local/index.js';
+export type { RemoteDBAdapter } from '../adapters/remote/index.js';
+export * from '../utils/logger.js';

package/dist/core/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Provider-independent entry point: no config resolvers, UI, or backend implementations.
+__exportStar(require("./client.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./query.js"), exports);
+__exportStar(require("./sync-worker.js"), exports);
+__exportStar(require("./conflict.js"), exports);
+__exportStar(require("./outbox-store.js"), exports);
+__exportStar(require("./meta-store.js"), exports);
+__exportStar(require("./table-manager.js"), exports);
+__exportStar(require("./schema-manager.js"), exports);
+__exportStar(require("./query-builder.js"), exports);
+__exportStar(require("../reactive/event-emitter.js"), exports);
+__exportStar(require("../adapters/network/index.js"), exports);
+__exportStar(require("../utils/logger.js"), exports);