local-lite 0.0.5 → 0.0.6

package/dist/adapters/remote/supabase.js

@@ -137,20 +137,9 @@ class SupabaseRemoteAdapter {
                     batch.push(operations[i]);
                     i++;
                 }
-                const buildRowData = (item) => {
-                    const row = {
-                        ...(item.payload || {}),
-                        [this.primaryKey]: item.rowId,
-                        [this.deletedColumn]: false,
-                    };
-                    if (this.updatedAtColumn && !row[this.updatedAtColumn]) {
-                        row[this.updatedAtColumn] = new Date(item.timestamp).toISOString();
-                    }
-                    return row;
-                };
                 if (batch.length === 1) {
                     try {
-                        const rowData = buildRowData(batch[0]);
+                        const rowData = this.buildRowData(batch[0]);
                         const { error } = await client.from(op.tableName).upsert(rowData);
                         if (error) {
                             const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'INSERT' });
@@ -174,7 +163,7 @@ class SupabaseRemoteAdapter {
                     const retryIndividually = async () => {
                         for (const item of batch) {
                             try {
-                                const singleRow = buildRowData(item);
+                                const singleRow = this.buildRowData(item);
                                 const { error: singleErr } = await client.from(op.tableName).upsert(singleRow);
                                 if (singleErr) {
                                     const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'INSERT' });
@@ -193,7 +182,7 @@ class SupabaseRemoteAdapter {
                         }
                     };
                     try {
-                        const rows = batch.map(buildRowData);
+                        const rows = batch.map((item) => this.buildRowData(item));
                         const { error } = await client.from(op.tableName).upsert(rows);
                         if (!error) {
                             for (const item of batch)
@@ -209,87 +198,173 @@ class SupabaseRemoteAdapter {
                 }
                 continue;
             }
-            // Handle DELETE
+            // Batch consecutive DELETEs for the same table
             if (op.operation === 'DELETE') {
-                try {
-                    const patch = {
-                        [this.deletedColumn]: this.deletedValue,
-                    };
-                    if (this.updatedAtColumn) {
-                        patch[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
+                const batch = [];
+                while (i < operations.length &&
+                    operations[i].operation === 'DELETE' &&
+                    operations[i].tableName === op.tableName) {
+                    batch.push(operations[i]);
+                    i++;
+                }
+                const patch = {
+                    [this.deletedColumn]: this.deletedValue,
+                };
+                if (this.updatedAtColumn) {
+                    patch[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
+                }
+                if (batch.length === 1) {
+                    try {
+                        const { error } = await client
+                            .from(op.tableName)
+                            .update(patch)
+                            .eq(this.primaryKey, op.rowId);
+                        if (error) {
+                            const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'DELETE' });
+                            this.logger.error(msg);
+                            failedIds.push(op.id);
+                            errors[op.id] = msg;
+                        }
+                        else {
+                            successfulIds.push(op.id);
+                        }
                     }
-                    const { error } = await client
-                        .from(op.tableName)
-                        .update(patch)
-                        .eq(this.primaryKey, op.rowId);
-                    if (error) {
-                        const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'DELETE' });
+                    catch (err) {
+                        const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'DELETE' });
                         this.logger.error(msg);
                         failedIds.push(op.id);
                         errors[op.id] = msg;
                     }
-                    else {
-                        successfulIds.push(op.id);
-                    }
                 }
-                catch (err) {
-                    const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'DELETE' });
-                    this.logger.error(msg);
-                    failedIds.push(op.id);
-                    errors[op.id] = msg;
+                else {
+                    // Bulk soft-delete using .in() to collapse N round-trips into 1
+                    const rowIds = batch.map((item) => item.rowId);
+                    try {
+                        const { error } = await client
+                            .from(op.tableName)
+                            .update(patch)
+                            .in(this.primaryKey, rowIds);
+                        if (!error) {
+                            for (const item of batch)
+                                successfulIds.push(item.id);
+                        }
+                        else {
+                            // Fallback to individual updates if .in() fails
+                            for (const item of batch) {
+                                try {
+                                    const { error: singleErr } = await client
+                                        .from(op.tableName)
+                                        .update(patch)
+                                        .eq(this.primaryKey, item.rowId);
+                                    if (singleErr) {
+                                        const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'DELETE' });
+                                        failedIds.push(item.id);
+                                        errors[item.id] = msg;
+                                    }
+                                    else {
+                                        successfulIds.push(item.id);
+                                    }
+                                }
+                                catch (singleErr) {
+                                    const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'DELETE' });
+                                    failedIds.push(item.id);
+                                    errors[item.id] = msg;
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        for (const item of batch)
+                            failedIds.push(item.id);
+                    }
                 }
-                i++;
                 continue;
             }
-            // Handle UPDATE
+            // Batch consecutive UPDATEs for the same table
             if (op.operation === 'UPDATE') {
-                try {
-                    const patch = {
-                        ...(op.payload || {}),
-                        [this.deletedColumn]: false,
-                    };
-                    if (this.updatedAtColumn) {
-                        patch[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
+                const batch = [];
+                while (i < operations.length &&
+                    operations[i].operation === 'UPDATE' &&
+                    operations[i].tableName === op.tableName) {
+                    batch.push(operations[i]);
+                    i++;
+                }
+                if (batch.length === 1) {
+                    const item = batch[0];
+                    try {
+                        const patch = this.buildRowData(item);
+                        const { error, data } = await client
+                            .from(op.tableName)
+                            .update(patch)
+                            .eq(this.primaryKey, item.rowId)
+                            .select(this.primaryKey);
+                        if (error) {
+                            const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'UPDATE' });
+                            this.logger.error(msg);
+                            failedIds.push(item.id);
+                            errors[item.id] = msg;
+                        }
+                        else if (!data || data.length === 0) {
+                            const { error: upsertErr } = await client.from(op.tableName).upsert(patch);
+                            if (upsertErr) {
+                                const msg = (0, logger_js_1.formatSupabaseError)(upsertErr, { table: op.tableName, operation: 'UPSERT_FALLBACK' });
+                                this.logger.error(msg);
+                                failedIds.push(item.id);
+                                errors[item.id] = msg;
+                            }
+                            else {
+                                successfulIds.push(item.id);
+                            }
+                        }
+                        else {
+                            successfulIds.push(item.id);
+                        }
                     }
-                    const { error, data } = await client
-                        .from(op.tableName)
-                        .update(patch)
-                        .eq(this.primaryKey, op.rowId)
-                        .select(this.primaryKey);
-                    if (error) {
-                        const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'UPDATE' });
+                    catch (err) {
+                        const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'UPDATE' });
                         this.logger.error(msg);
-                        failedIds.push(op.id);
-                        errors[op.id] = msg;
+                        failedIds.push(item.id);
+                        errors[item.id] = msg;
                     }
-                    else if (!data || data.length === 0) {
-                        // If row did not exist remotely, fallback to upsert
-                        const rowData = {
-                            ...patch,
-                            [this.primaryKey]: op.rowId,
-                        };
-                        const { error: upsertErr } = await client.from(op.tableName).upsert(rowData);
-                        if (upsertErr) {
-                            const msg = (0, logger_js_1.formatSupabaseError)(upsertErr, { table: op.tableName, operation: 'UPSERT_FALLBACK' });
-                            this.logger.error(msg);
-                            failedIds.push(op.id);
-                            errors[op.id] = msg;
+                }
+                else {
+                    // Bulk upsert for multiple consecutive updates (merges fields by primaryKey in 1 HTTP call)
+                    const rows = batch.map((item) => this.buildRowData(item));
+                    try {
+                        const { error } = await client.from(op.tableName).upsert(rows);
+                        if (!error) {
+                            for (const item of batch)
+                                successfulIds.push(item.id);
                         }
                         else {
-                            successfulIds.push(op.id);
+                            // Fallback to individual updates if bulk upsert has a schema conflict
+                            for (const item of batch) {
+                                try {
+                                    const singleRow = this.buildRowData(item);
+                                    const { error: singleErr } = await client.from(op.tableName).upsert(singleRow);
+                                    if (singleErr) {
+                                        const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'UPDATE' });
+                                        failedIds.push(item.id);
+                                        errors[item.id] = msg;
+                                    }
+                                    else {
+                                        successfulIds.push(item.id);
+                                    }
+                                }
+                                catch (singleErr) {
+                                    const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'UPDATE' });
+                                    failedIds.push(item.id);
+                                    errors[item.id] = msg;
+                                }
+                            }
                         }
                     }
-                    else {
-                        successfulIds.push(op.id);
+                    catch {
+                        for (const item of batch) {
+                            failedIds.push(item.id);
+                        }
                     }
                 }
-                catch (err) {
-                    const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'UPDATE' });
-                    this.logger.error(msg);
-                    failedIds.push(op.id);
-                    errors[op.id] = msg;
-                }
-                i++;
                 continue;
             }
             i++;
@@ -438,6 +513,20 @@ class SupabaseRemoteAdapter {
             changes,
         };
     }
+    /**
+     * Formats a row payload for remote Supabase storage (adds primaryKey, deleted: false, updated_at).
+     */
+    buildRowData(item) {
+        const row = {
+            ...(item.payload || {}),
+            [this.primaryKey]: item.rowId,
+            [this.deletedColumn]: false,
+        };
+        if (this.updatedAtColumn && !row[this.updatedAtColumn]) {
+            row[this.updatedAtColumn] = new Date(item.timestamp).toISOString();
+        }
+        return row;
+    }
     /**
      * Helper to determine if a record represents a soft delete.
      */
@@ -454,6 +543,7 @@ class SupabaseRemoteAdapter {
     }
     /**
      * Subscribes to live realtime postgres_changes from Supabase.
+     * Batches rapid burst events in the same microtask turn into a single SQLite sync transaction.
      */
     subscribeToLiveChanges(callback) {
         this.activeLiveCallback = callback;
@@ -479,6 +569,23 @@ class SupabaseRemoteAdapter {
             };
         }
         const channel = client.channel(this.channelName);
+        let pendingLiveChanges = [];
+        let isScheduled = false;
+        const flushLiveChanges = () => {
+            isScheduled = false;
+            if (pendingLiveChanges.length === 0)
+                return;
+            const toSend = pendingLiveChanges;
+            pendingLiveChanges = [];
+            const maxTimestamp = Math.max(...toSend.map((c) => c.timestamp || 0), Date.now());
+            callback({
+                timestamp: maxTimestamp,
+                changes: toSend,
+            });
+        };
+        const scheduleFlush = typeof queueMicrotask === 'function'
+            ? queueMicrotask
+            : (fn) => setTimeout(fn, 0);
         for (const table of this.tables) {
             channel.on('postgres_changes', { event: '*', schema: this.schema, table }, (payload) => {
                 let op = 'UPDATE';
@@ -495,18 +602,17 @@ class SupabaseRemoteAdapter {
                 const timestamp = record[this.updatedAtColumn]
                     ? new Date(record[this.updatedAtColumn]).getTime()
                     : Date.now();
-                callback({
+                pendingLiveChanges.push({
+                    tableName: table,
+                    operation: finalOp,
+                    rowId,
+                    payload: finalOp === 'DELETE' ? null : record,
                     timestamp,
-                    changes: [
-                        {
-                            tableName: table,
-                            operation: finalOp,
-                            rowId,
-                            payload: finalOp === 'DELETE' ? null : record,
-                            timestamp,
-                        },
-                    ],
                 });
+                if (!isScheduled) {
+                    isScheduled = true;
+                    scheduleFlush(flushLiveChanges);
+                }
             });
         }
         channel.subscribe((status) => {
@@ -516,6 +622,7 @@ class SupabaseRemoteAdapter {
         });
         this.activeChannel = channel;
         return () => {
+            flushLiveChanges();
             this.activeLiveCallback = undefined;
             this.destroy();
         };

package/dist/core/client.d.ts

@@ -212,14 +212,6 @@ export declare class LocalFirstClient {
     findById<T = any>(tableName: string, id: string, options?: {
         includeDeleted?: boolean;
     }): Promise<T | null>;
-    /**
-     * 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']);
-     */
     findByIds<T = any>(tableName: string, ids: string[], options?: {
         includeDeleted?: boolean;
     }): Promise<T[]>;

package/dist/core/client.js

@@ -11,6 +11,43 @@ 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");
+async function executeFindById(db, tableName, id, primaryKey, hydrateRow, includeDeleted) {
+    const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+    const safePk = (0, sql_js_1.escapeIdentifier)(primaryKey);
+    try {
+        const rows = await db.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} = ? LIMIT 1`, [id]);
+        if (!rows || rows.length === 0)
+            return null;
+        const row = hydrateRow(tableName, rows[0]);
+        return !includeDeleted && (0, query_js_1.isDeletedRecord)(row) ? null : row;
+    }
+    catch (err) {
+        const msg = String(err?.message || err || '');
+        if (msg.includes('no such table') || msg.includes('no such column'))
+            return null;
+        throw err;
+    }
+}
+async function executeFindByIds(db, tableName, ids, primaryKey, hydrateRow, includeDeleted) {
+    if (!ids || ids.length === 0)
+        return [];
+    const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+    const safePk = (0, sql_js_1.escapeIdentifier)(primaryKey);
+    const placeholders = ids.map(() => '?').join(', ');
+    try {
+        const rows = await db.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} IN (${placeholders})`, ids);
+        if (!rows || rows.length === 0)
+            return [];
+        const hydrated = rows.map((r) => hydrateRow(tableName, r));
+        return !includeDeleted ? hydrated.filter((r) => !(0, query_js_1.isDeletedRecord)(r)) : hydrated;
+    }
+    catch (err) {
+        const msg = String(err?.message || err || '');
+        if (msg.includes('no such table') || msg.includes('no such column'))
+            return [];
+        throw err;
+    }
+}
 class TransactionalClient {
     parent;
     tx;
@@ -74,41 +111,10 @@ class TransactionalClient {
         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;
-        }
+        return executeFindById(this.tx, tableName, id, this.parent.getPrimaryKey(), (t, r) => this.parent.hydrateRow(t, r), options?.includeDeleted);
     }
     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 [];
-        }
+        return executeFindByIds(this.tx, tableName, ids, this.parent.getPrimaryKey(), (t, r) => this.parent.hydrateRow(t, r), options?.includeDeleted);
     }
     async findMany(tableName, options) {
         const rows = await this.from(tableName).applyOptions(options).execute();
@@ -274,6 +280,15 @@ class LocalFirstClient {
         await this.initialization;
     }
     async initializeStorage() {
+        try {
+            await this.db.execute('PRAGMA journal_mode = WAL;');
+            await this.db.execute('PRAGMA synchronous = NORMAL;');
+            await this.db.execute('PRAGMA busy_timeout = 5000;');
+            await this.db.execute('PRAGMA cache_size = -64000;');
+        }
+        catch {
+            // Ignored for drivers, mock DBs, or in-memory modes that do not support PRAGMAs
+        }
         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);
@@ -344,6 +359,7 @@ class LocalFirstClient {
         const generatedIds = [];
         const queuedEvents = [];
         const queuedOutboxIds = [];
+        const pendingOutboxOps = [];
         const executeInTx = async (tx) => {
             for (const m of mutations) {
                 const pk = m.primaryKey ?? options.primaryKey ?? this.primaryKey;
@@ -360,8 +376,22 @@ class LocalFirstClient {
                 const skipOutbox = m.skipOutbox ?? options.skipOutbox ?? false;
                 if (!skipOutbox) {
                     const timestamp = m.customTimestamp ?? options.customTimestamp ?? Date.now();
-                    const outboxId = await this.recordOutboxMutation(tx, m.tableName, rowId, m.operation, payload, timestamp);
-                    if (outboxId) {
+                    if (this.coalesceOutbox && m.operation !== 'INSERT') {
+                        const outboxId = await this.recordOutboxMutation(tx, m.tableName, rowId, m.operation, payload, timestamp);
+                        if (outboxId) {
+                            queuedOutboxIds.push(outboxId);
+                        }
+                    }
+                    else {
+                        const outboxId = (0, uuid_js_1.generateUUID)();
+                        pendingOutboxOps.push({
+                            id: outboxId,
+                            tableName: m.tableName,
+                            rowId,
+                            operation: m.operation,
+                            payload,
+                            timestamp,
+                        });
                         queuedOutboxIds.push(outboxId);
                     }
                 }
@@ -375,6 +405,9 @@ class LocalFirstClient {
                     },
                 });
             }
+            if (pendingOutboxOps.length > 0) {
+                await outbox_store_js_1.OutboxStore.insertRecords(tx, pendingOutboxOps);
+            }
         };
         if (options.tx) {
             await executeInTx(options.tx);
@@ -639,59 +672,10 @@ class LocalFirstClient {
      * 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);
-        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;
-        }
+        return executeFindById(this.db, tableName, id, this.primaryKey, (t, r) => this.hydrateRow(t, r), options?.includeDeleted);
     }
-    /**
-     * 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;
-        }
+        return executeFindByIds(this.db, tableName, ids, this.primaryKey, (t, r) => this.hydrateRow(t, r), options?.includeDeleted);
     }
     /**
      * Tracks an existing mutation into sync_outbox without modifying the table.

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

@@ -21,6 +21,11 @@ export declare class OutboxStore {
      * Finds the latest pending outbox record for a given table and row.
      */
     static findPendingByRow(tx: LocalTransaction, tableName: string, rowId: string): Promise<OutboxRecord | undefined>;
+    /**
+     * Retrieves active (non-FAILED) pending outbox records indexed by `${table_name}:${row_id}`.
+     * Enables O(1) in-memory conflict lookup during delta ingestion, eliminating N+1 queries.
+     */
+    static getActivePendingMap(tx: LocalTransaction): Promise<Map<string, OutboxRecord>>;
     /**
      * Marks a batch of outbox IDs as 'PROCESSING'.
      */

package/dist/core/outbox-store.js

@@ -36,6 +36,7 @@ class OutboxStore {
         // Indexes for the hot paths: pending scans (push), per-row conflict lookups (pull),
         // and status counts (telemetry). Executed separately: many drivers prepare one statement.
         await db.execute(`CREATE INDEX IF NOT EXISTS idx_sync_outbox_status_ts ON sync_outbox (status, timestamp);`);
+        await db.execute(`CREATE INDEX IF NOT EXISTS idx_sync_outbox_status_retry ON sync_outbox (status, retry_count, timestamp);`);
         await db.execute(`CREATE INDEX IF NOT EXISTS idx_sync_outbox_row ON sync_outbox (table_name, row_id, timestamp);`);
     }
     /**
@@ -107,6 +108,30 @@ class OutboxStore {
             return undefined;
         return mapOutboxRow(rows[0]);
     }
+    /**
+     * Retrieves active (non-FAILED) pending outbox records indexed by `${table_name}:${row_id}`.
+     * Enables O(1) in-memory conflict lookup during delta ingestion, eliminating N+1 queries.
+     */
+    static async getActivePendingMap(tx) {
+        const map = new Map();
+        try {
+            const rows = await tx.execute(`SELECT * FROM sync_outbox WHERE status != 'FAILED' ORDER BY timestamp DESC`);
+            if (!rows || rows.length === 0)
+                return map;
+            for (const r of rows) {
+                const record = mapOutboxRow(r);
+                const key = `${record.tableName}:${record.rowId}`;
+                // Preserve the latest record for each table_name:row_id
+                if (!map.has(key)) {
+                    map.set(key, record);
+                }
+            }
+            return map;
+        }
+        catch {
+            return map;
+        }
+    }
     /**
      * Marks a batch of outbox IDs as 'PROCESSING'.
      */
@@ -216,8 +241,8 @@ class OutboxStore {
                 return ids.length;
             }
             else {
-                const failedRecords = await db.execute(`SELECT id FROM sync_outbox WHERE status = 'FAILED'`);
-                const count = failedRecords?.length || 0;
+                const rows = await db.execute(`SELECT COUNT(*) AS count FROM sync_outbox WHERE status = 'FAILED'`);
+                const count = Number(rows?.[0]?.count ?? (Array.isArray(rows) ? rows.length : 0));
                 if (count > 0) {
                     await db.execute(`UPDATE sync_outbox SET status = 'PENDING', retry_count = 0, last_error = NULL WHERE status = 'FAILED'`);
                 }
@@ -239,8 +264,8 @@ class OutboxStore {
                 return ids.length;
             }
             else {
-                const failedRecords = await db.execute(`SELECT id FROM sync_outbox WHERE status = 'FAILED'`);
-                const count = failedRecords?.length || 0;
+                const rows = await db.execute(`SELECT COUNT(*) AS count FROM sync_outbox WHERE status = 'FAILED'`);
+                const count = Number(rows?.[0]?.count ?? (Array.isArray(rows) ? rows.length : 0));
                 if (count > 0) {
                     await db.execute(`DELETE FROM sync_outbox WHERE status = 'FAILED'`);
                 }

package/dist/core/query-builder.d.ts

@@ -90,6 +90,7 @@ export declare class QueryBuilder<T = any> {
     applyOptions(options?: QueryOptions): this;
     /**
      * Compiles the current builder state into an executable SQL string and parameter list.
+     * Uses module-scoped compileComparison / compileWhereConditions helpers (defined once).
      */
     toSQL(): {
         sql: string;