local-lite 0.0.3 → 0.0.4

package/dist/core/client.js

@@ -23,22 +23,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 +64,54 @@ 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) {
+        return this.parent.findManyInternal(this.tx, tableName, options);
+    }
     get rawTx() {
         return this.tx;
     }
@@ -85,15 +124,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 +157,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 +291,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 +301,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 +318,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 +351,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 +456,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,6 +489,7 @@ 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.
      *
      * Example:
@@ -328,19 +497,137 @@ class LocalFirstClient {
      * const expensive = await client.findMany('properties', { where: { rent: { $gte: 2000 } } });
      */
     async findMany(tableName, options) {
+        return this.findManyInternal(this.db, tableName, options);
+    }
+    /**
+     * Internal findMany implementation shared between LocalFirstClient and TransactionalClient.
+     */
+    async findManyInternal(db, tableName, options) {
+        await this.schemaManager.ensureTableIntrospected(db, tableName);
         const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
         let rows;
+        const projection = options?.select && Array.isArray(options.select) && options.select.length > 0
+            ? options.select.map(sql_js_1.escapeIdentifier).join(', ')
+            : '*';
+        let sql = `SELECT ${projection} FROM ${safeTable}`;
+        const params = [];
+        const whereClauses = [];
+        // Automatically push down soft-delete filter if table has deleted column and not explicitly overridden
+        const hasDeletedClause = options?.where && typeof options.where === 'object' && (0, query_js_1.hasExplicitDeletedFilter)(options.where);
+        if (!options?.includeDeleted && !hasDeletedClause && this.schemaManager.hasColumn(tableName, 'deleted')) {
+            const safeDel = (0, sql_js_1.escapeIdentifier)('deleted');
+            whereClauses.push(`(${safeDel} IS NULL OR (${safeDel} != 1 AND ${safeDel} != 'true'))`);
+        }
+        // Push down where conditions to SQLite
+        if (options?.where && typeof options.where === 'object' && !Array.isArray(options.where)) {
+            for (const [col, filter] of Object.entries(options.where)) {
+                if (col === '$or' || col === '$and')
+                    continue;
+                const safeCol = (0, sql_js_1.escapeIdentifier)(col);
+                if (filter === null) {
+                    whereClauses.push(`${safeCol} IS NULL`);
+                }
+                else if (typeof filter === 'boolean') {
+                    whereClauses.push(`${safeCol} = ?`);
+                    params.push(filter ? 1 : 0);
+                }
+                else if (typeof filter === 'string' || typeof filter === 'number') {
+                    whereClauses.push(`${safeCol} = ?`);
+                    params.push(filter);
+                }
+                else if (typeof filter === 'object' && !Array.isArray(filter)) {
+                    const ops = filter;
+                    if (ops.$eq !== undefined) {
+                        whereClauses.push(`${safeCol} = ?`);
+                        params.push(typeof ops.$eq === 'boolean' ? (ops.$eq ? 1 : 0) : ops.$eq);
+                    }
+                    if (ops.$ne !== undefined) {
+                        whereClauses.push(`${safeCol} != ?`);
+                        params.push(typeof ops.$ne === 'boolean' ? (ops.$ne ? 1 : 0) : ops.$ne);
+                    }
+                    if (ops.$gt !== undefined) {
+                        whereClauses.push(`${safeCol} > ?`);
+                        params.push(ops.$gt);
+                    }
+                    if (ops.$gte !== undefined) {
+                        whereClauses.push(`${safeCol} >= ?`);
+                        params.push(ops.$gte);
+                    }
+                    if (ops.$lt !== undefined) {
+                        whereClauses.push(`${safeCol} < ?`);
+                        params.push(ops.$lt);
+                    }
+                    if (ops.$lte !== undefined) {
+                        whereClauses.push(`${safeCol} <= ?`);
+                        params.push(ops.$lte);
+                    }
+                    if (Array.isArray(ops.$in) && ops.$in.length > 0) {
+                        const placeholders = ops.$in.map(() => '?').join(', ');
+                        whereClauses.push(`${safeCol} IN (${placeholders})`);
+                        params.push(...ops.$in.map((v) => (typeof v === 'boolean' ? (v ? 1 : 0) : v)));
+                    }
+                    if (Array.isArray(ops.$nin) && ops.$nin.length > 0) {
+                        const placeholders = ops.$nin.map(() => '?').join(', ');
+                        whereClauses.push(`${safeCol} NOT IN (${placeholders})`);
+                        params.push(...ops.$nin.map((v) => (typeof v === 'boolean' ? (v ? 1 : 0) : v)));
+                    }
+                    if (ops.$null !== undefined) {
+                        whereClauses.push(ops.$null ? `${safeCol} IS NULL` : `${safeCol} IS NOT NULL`);
+                    }
+                    if (ops.$contains !== undefined) {
+                        whereClauses.push(`${safeCol} LIKE ?`);
+                        params.push(`%${ops.$contains}%`);
+                    }
+                    if (ops.$startsWith !== undefined) {
+                        whereClauses.push(`${safeCol} LIKE ?`);
+                        params.push(`${ops.$startsWith}%`);
+                    }
+                    if (ops.$endsWith !== undefined) {
+                        whereClauses.push(`${safeCol} LIKE ?`);
+                        params.push(`%${ops.$endsWith}`);
+                    }
+                }
+            }
+            if (whereClauses.length > 0) {
+                sql += ` WHERE ${whereClauses.join(' AND ')}`;
+            }
+        }
+        // Push down ORDER BY
+        if (options?.orderBy && typeof options.orderBy === 'string') {
+            const safeCol = (0, sql_js_1.escapeIdentifier)(options.orderBy);
+            const dir = options.order && String(options.order).toLowerCase() === 'desc' ? 'DESC' : 'ASC';
+            sql += ` ORDER BY ${safeCol} ${dir}`;
+        }
+        // Push down LIMIT & OFFSET
+        if (typeof options?.limit === 'number' && options.limit > 0) {
+            sql += ` LIMIT ?`;
+            params.push(options.limit);
+            if (typeof options.offset === 'number' && options.offset > 0) {
+                sql += ` OFFSET ?`;
+                params.push(options.offset);
+            }
+        }
         try {
-            rows = await this.db.execute(`SELECT * FROM ${safeTable}`);
+            rows = await db.execute(sql, params);
         }
         catch (err) {
             const msg = String(err?.message || err || '');
             if (msg.includes('no such table') || msg.includes('no such column')) {
                 return [];
             }
-            throw err;
+            // Fallback to select * if pushdown syntax differs
+            try {
+                rows = await db.execute(`SELECT * FROM ${safeTable}`);
+            }
+            catch {
+                return [];
+            }
         }
-        return (0, query_js_1.applyQueryOptions)(rows, options);
+        const hasJsonConfig = Boolean(this.jsonColumns[tableName] || this.autoHydrateJSON);
+        const hydratedRows = hasJsonConfig
+            ? rows.map((r) => this.hydrateRow(tableName, r))
+            : rows;
+        return (0, query_js_1.applyQueryOptions)(hydratedRows, options);
     }
     /**
      * Finds a single record by primary key.
@@ -348,12 +635,60 @@ class LocalFirstClient {
      * Example:
      * const tenant = await client.findById('tenants', 'ten-1');
      */
-    async findById(tableName, id) {
-        const results = await this.findMany(tableName, {
-            where: { [this.primaryKey]: id },
-            limit: 1,
-        });
-        return results.length > 0 ? results[0] : null;
+    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);
+        const safePk = (0, sql_js_1.escapeIdentifier)(this.primaryKey);
+        try {
+            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 null;
+            }
+            throw err;
+        }
+    }
+    /**
+     * 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 tenants = await client.findByIds('tenants', ['ten-1', 'ten-2', 'ten-3']);
+     */
+    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 +770,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,14 @@
+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 '../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,29 @@
+"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("../reactive/event-emitter.js"), exports);
+__exportStar(require("../adapters/network/index.js"), exports);
+__exportStar(require("../utils/logger.js"), exports);

package/dist/core/outbox-store.d.ts

@@ -1,5 +1,5 @@
 import { LocalDBAdapter, LocalTransaction } from '../adapters/local/index.js';
-import { OutboxRecord, OutboxStatus, SyncOperation } from './types.js';
+import { OutboxRecord, OutboxStatus, SyncOp, SyncOperation } from './types.js';
 export declare class OutboxStore {
     /**
      * Initializes the sync_outbox schema if it does not already exist.
@@ -10,7 +10,7 @@ export declare class OutboxStore {
      */
     static insertRecord(tx: LocalTransaction, op: SyncOperation): Promise<void>;
     /**
-     * Inserts multiple outbox entries within an existing database transaction.
+     * Inserts multiple outbox entries in high-throughput multi-row SQL chunks within an existing transaction.
      */
     static insertRecords(tx: LocalTransaction, ops: SyncOperation[]): Promise<void>;
     /**
@@ -39,9 +39,13 @@ export declare class OutboxStore {
      */
     static deleteRecord(tx: LocalTransaction, id: string): Promise<void>;
     /**
-     * Updates an outbox record's payload (used during conflict merge).
+     * Updates an outbox record's payload (used during conflict merge or coalescing).
      */
-    static updatePayload(tx: LocalTransaction, id: string, payload: Record<string, any>): Promise<void>;
+    static updatePayload(tx: LocalTransaction, id: string, payload: Record<string, any>, timestamp?: number): Promise<void>;
+    /**
+     * Updates an outbox record's operation and payload (used during mutation coalescing).
+     */
+    static updateOperation(tx: LocalTransaction, id: string, operation: SyncOp, payload: Record<string, any> | null, timestamp?: number): Promise<void>;
     /**
      * Marks a batch of outbox IDs as 'FAILED' and increments retry counters.
      */