local-lite 0.0.12 → 0.0.15

package/dist/backups/onedrive.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneDriveBackupClient = exports.OneDriveBackupStorage = exports.MICROSOFT_GRAPH_DRIVE = void 0;
+const microsoft_js_1 = require("../auth/microsoft.js");
+exports.MICROSOFT_GRAPH_DRIVE = 'https://graph.microsoft.com/v1.0/me/drive';
+const BACKUP_FOLDER = 'backups';
+class OneDriveBackupStorage {
+    getAccessToken;
+    fetcher;
+    constructor(getAccessToken, fetcher = fetch) {
+        this.getAccessToken = getAccessToken;
+        this.fetcher = fetcher;
+    }
+    async save(fileName, data) {
+        const token = await this.getAccessToken();
+        const encodedName = encodeURIComponent(fileName);
+        const url = `${exports.MICROSOFT_GRAPH_DRIVE}/special/approot:/${BACKUP_FOLDER}/${encodedName}:/content`;
+        const response = await this.fetcher(url, {
+            method: 'PUT',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/octet-stream',
+            },
+            body: data.slice().buffer,
+        });
+        if (!response.ok) {
+            let detail = '';
+            try {
+                const body = (await response.json());
+                detail = body?.error?.message || response.statusText;
+            }
+            catch {
+                detail = response.statusText;
+            }
+            throw new Error(`OneDrive upload failed (${response.status}): ${detail}`);
+        }
+    }
+    async read(fileIdOrName) {
+        const token = await this.getAccessToken();
+        let url = `${exports.MICROSOFT_GRAPH_DRIVE}/items/${encodeURIComponent(fileIdOrName)}/content`;
+        // Support reading directly by filename inside approot:/backups/
+        if (fileIdOrName.endsWith('.db') && !fileIdOrName.startsWith('item-')) {
+            url = `${exports.MICROSOFT_GRAPH_DRIVE}/special/approot:/${BACKUP_FOLDER}/${encodeURIComponent(fileIdOrName)}:/content`;
+        }
+        const response = await this.fetcher(url, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!response.ok) {
+            throw new Error(`OneDrive download failed (${response.status}): ${response.statusText}`);
+        }
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    async list() {
+        const token = await this.getAccessToken();
+        const url = `${exports.MICROSOFT_GRAPH_DRIVE}/special/approot:/${BACKUP_FOLDER}:/children?$select=id,name,size,lastModifiedDateTime`;
+        const response = await this.fetcher(url, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (response.status === 404) {
+            return []; // Folder does not exist yet
+        }
+        if (!response.ok) {
+            throw new Error(`OneDrive list failed (${response.status}): ${response.statusText}`);
+        }
+        const result = (await response.json());
+        return (result.value ?? [])
+            .filter(item => item.name.endsWith('.db'))
+            .map(item => ({
+            id: item.id,
+            name: item.name,
+            size: item.size,
+            modifiedAt: item.lastModifiedDateTime,
+        }));
+    }
+}
+exports.OneDriveBackupStorage = OneDriveBackupStorage;
+class OneDriveBackupClient {
+    storage;
+    authClient;
+    constructor(options) {
+        const scopes = options.scopes ?? [
+            'openid',
+            'profile',
+            'email',
+            'User.Read',
+            'Files.ReadWrite.AppFolder',
+        ];
+        this.authClient = new microsoft_js_1.MicrosoftAuthClient({
+            ...options,
+            scopes,
+        });
+        this.storage = new OneDriveBackupStorage(() => this.authClient.getValidAccessToken(), options.fetch ?? fetch);
+    }
+    async connect() {
+        const user = await this.authClient.signIn();
+        return user !== null;
+    }
+    async disconnect() {
+        await this.authClient.signOut();
+    }
+    async isConnected() {
+        return this.authClient.isSignedIn();
+    }
+    save(fileName, data) {
+        return this.storage.save(fileName, data);
+    }
+    read(fileId) {
+        return this.storage.read(fileId);
+    }
+    list() {
+        return this.storage.list();
+    }
+}
+exports.OneDriveBackupClient = OneDriveBackupClient;

package/dist/core/client.d.ts

@@ -2,10 +2,12 @@ import { LocalDBAdapter, LocalTransaction } from '../adapters/local/index.js';
 import { RemoteDBAdapter } from '../adapters/remote/index.js';
 import { EventEmitter } from '../reactive/event-emitter.js';
 import { SyncWorker } from './sync-worker.js';
+import { DatabaseMaintenance } from './maintenance.js';
 import { SchemaManager } from './schema-manager.js';
 import { BatchMutation, ConflictResolver, ConflictStrategy, MutateOptions, NetworkStatusProvider, OutboxRecord, OutboxStatus, QueryOptions, RetryConfig, SyncMetrics, SyncOp, TableChangeEvent, WhereFilter } from './types.js';
 import { SyncLogger, CustomLogger, LogLevel } from '../utils/logger.js';
 import { QueryBuilder, AggregateSpec, AggregateResult } from './query-builder.js';
+import { type ExportJsonOptions, type ImportJsonOptions, type ExportCsvOptions, type ImportCsvOptions, type ImportSummary } from '../utils/portability.js';
 export interface LocalFirstClientConfig {
     local: LocalDBAdapter;
     remote: RemoteDBAdapter;
@@ -61,6 +63,10 @@ export declare class TransactionalClient {
         includeDeleted?: boolean;
     }): Promise<T[]>;
     findMany<T = any>(tableName: string, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Alias for findMany().
+     */
+    find<T = any>(tableName: string, options?: QueryOptions): Promise<T[]>;
     query<T = any>(sql: string, params?: any[]): Promise<T[]>;
     from<T = any>(tableName: string): QueryBuilder<T>;
     get rawTx(): LocalTransaction;
@@ -78,6 +84,7 @@ export declare class LocalFirstClient {
     autoHydrateJSON: boolean;
     /** Local column stamped on INSERT/UPDATE writes, or null when disabled. */
     touchColumn: string | null;
+    readonly maintenance: DatabaseMaintenance;
     private primaryKey;
     private migrations;
     private autoStart;
@@ -225,6 +232,32 @@ export declare class LocalFirstClient {
      */
     aggregate(tableName: string, spec: AggregateSpec): Promise<AggregateResult>;
     findMany<T = any>(tableName: string, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Alias for findMany().
+     */
+    find<T = any>(tableName: string, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Returns true if client storage has successfully initialized.
+     */
+    get isReady(): boolean;
+    /**
+     * Convenience export of tables to JSON.
+     */
+    exportToJson(tables?: string[], options?: ExportJsonOptions): Promise<string>;
+    /**
+     * Convenience import of tables from JSON.
+     */
+    importFromJson(jsonString: string, options?: ImportJsonOptions): Promise<ImportSummary>;
+    /**
+     * Convenience export of a table to RFC-4180 CSV.
+     */
+    exportToCsv(tableName: string, options?: ExportCsvOptions): Promise<string>;
+    /**
+     * Convenience import of RFC-4180 CSV into a table.
+     */
+    importFromCsv(tableName: string, csvString: string, options?: ImportCsvOptions): Promise<{
+        rowCount: number;
+    }>;
     /**
      * Finds a single record by primary key.
      *

package/dist/core/client.js

@@ -6,11 +6,13 @@ const sync_worker_js_1 = require("./sync-worker.js");
 const table_manager_js_1 = require("./table-manager.js");
 const outbox_store_js_1 = require("./outbox-store.js");
 const meta_store_js_1 = require("./meta-store.js");
+const maintenance_js_1 = require("./maintenance.js");
 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");
+const portability_js_1 = require("../utils/portability.js");
 function hasFunctionFilter(value) {
     if (typeof value === 'function')
         return true;
@@ -132,6 +134,12 @@ class TransactionalClient {
         }
         return this.from(tableName).applyOptions(options).execute();
     }
+    /**
+     * Alias for findMany().
+     */
+    async find(tableName, options) {
+        return this.findMany(tableName, options);
+    }
     async query(sql, params = []) {
         return (await this.tx.execute(sql, params));
     }
@@ -156,6 +164,7 @@ class LocalFirstClient {
     autoHydrateJSON;
     /** Local column stamped on INSERT/UPDATE writes, or null when disabled. */
     touchColumn;
+    maintenance;
     primaryKey;
     migrations;
     autoStart;
@@ -180,6 +189,7 @@ class LocalFirstClient {
                     ? touch
                     : this.remote?.updatedAtColumn || 'updated_at';
         this.schemaManager = new schema_manager_js_1.SchemaManager();
+        this.maintenance = new maintenance_js_1.DatabaseMaintenance(this.db, () => this.tables);
         const workerOptions = {
             network: config.network,
             conflictResolver: config.conflictResolver,
@@ -712,6 +722,42 @@ class LocalFirstClient {
         }
         return this.from(tableName).applyOptions(options).execute();
     }
+    /**
+     * Alias for findMany().
+     */
+    async find(tableName, options) {
+        return this.findMany(tableName, options);
+    }
+    /**
+     * Returns true if client storage has successfully initialized.
+     */
+    get isReady() {
+        return Boolean(this.initialization);
+    }
+    /**
+     * Convenience export of tables to JSON.
+     */
+    async exportToJson(tables, options) {
+        return (0, portability_js_1.exportTablesToJson)(this, tables, options);
+    }
+    /**
+     * Convenience import of tables from JSON.
+     */
+    async importFromJson(jsonString, options) {
+        return (0, portability_js_1.importTablesFromJson)(this, jsonString, options);
+    }
+    /**
+     * Convenience export of a table to RFC-4180 CSV.
+     */
+    async exportToCsv(tableName, options) {
+        return (0, portability_js_1.exportTableToCsv)(this, tableName, options);
+    }
+    /**
+     * Convenience import of RFC-4180 CSV into a table.
+     */
+    async importFromCsv(tableName, csvString, options) {
+        return (0, portability_js_1.importTableFromCsv)(this, tableName, csvString, options);
+    }
     /**
      * Finds a single record by primary key.
      *

package/dist/core/conflict.d.ts

@@ -1,5 +1,12 @@
-import { ConflictResolver, ConflictStrategy } from './types.js';
+import { ConflictContext, ConflictResolution, ConflictResolver, ConflictStrategy, FieldMergeResolverOptions } from './types.js';
+export type { ConflictContext, ConflictResolution, ConflictResolver, ConflictStrategy, FieldMergeResolverOptions, };
 export declare const lastWriteWinsResolver: ConflictResolver;
 export declare const serverWinsResolver: ConflictResolver;
 export declare const clientWinsResolver: ConflictResolver;
+/**
+ * Creates a smart 3-way field-level conflict resolver.
+ * Merges disjoint fields from both local and remote offline mutations,
+ * and resolves overlapping field changes using custom rules, timestamps, or winner strategies.
+ */
+export declare function createFieldMergeResolver(options?: FieldMergeResolverOptions): ConflictResolver;
 export declare function getConflictResolver(strategyOrResolver?: ConflictStrategy | ConflictResolver): ConflictResolver;

package/dist/core/conflict.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientWinsResolver = exports.serverWinsResolver = exports.lastWriteWinsResolver = void 0;
+exports.createFieldMergeResolver = createFieldMergeResolver;
 exports.getConflictResolver = getConflictResolver;
 const lastWriteWinsResolver = (context) => {
     const remoteTime = context.remoteChange.timestamp ?? 0;
@@ -22,6 +23,78 @@ const clientWinsResolver = (context) => {
     return 'apply-remote';
 };
 exports.clientWinsResolver = clientWinsResolver;
+/**
+ * Creates a smart 3-way field-level conflict resolver.
+ * Merges disjoint fields from both local and remote offline mutations,
+ * and resolves overlapping field changes using custom rules, timestamps, or winner strategies.
+ */
+function createFieldMergeResolver(options = {}) {
+    const defaultWinner = options.defaultWinner ?? 'newer';
+    const deleteHandling = options.deleteHandling ?? 'delete-wins';
+    const fieldRules = options.fieldRules ?? {};
+    return (context) => {
+        const isRemoteDelete = context.remoteChange.operation === 'DELETE';
+        const isLocalDelete = context.localOutboxRecord?.operation === 'DELETE';
+        if (isRemoteDelete && isLocalDelete) {
+            return 'apply-remote';
+        }
+        if (isRemoteDelete && !isLocalDelete) {
+            return deleteHandling === 'update-wins' ? 'keep-local' : 'apply-remote';
+        }
+        if (isLocalDelete && !isRemoteDelete) {
+            return deleteHandling === 'update-wins' ? 'apply-remote' : 'keep-local';
+        }
+        // Both are non-delete operations (INSERT / UPDATE)
+        const baseRow = context.localRow ?? {};
+        const remotePayload = context.remoteChange.payload ?? {};
+        const localPayload = context.localOutboxRecord?.payload ?? {};
+        const merged = { ...baseRow, ...remotePayload };
+        const tableRules = fieldRules[context.tableName] ?? {};
+        const wildcardRules = fieldRules['*'] ?? {};
+        const localTime = context.localOutboxRecord?.timestamp ?? 0;
+        const remoteTime = context.remoteChange.timestamp ?? 0;
+        for (const key of Object.keys(localPayload)) {
+            if (!(key in remotePayload)) {
+                // Field only changed locally: preserve local modification
+                merged[key] = localPayload[key];
+                continue;
+            }
+            // Field was modified by BOTH local and remote: resolve conflict
+            const rule = tableRules[key] ?? wildcardRules[key];
+            const localVal = localPayload[key];
+            const remoteVal = remotePayload[key];
+            if (typeof rule === 'function') {
+                merged[key] = rule(localVal, remoteVal, context);
+            }
+            else if (rule === 'max') {
+                merged[key] = localVal >= remoteVal ? localVal : remoteVal;
+            }
+            else if (rule === 'min') {
+                merged[key] = localVal <= remoteVal ? localVal : remoteVal;
+            }
+            else if (rule === 'local') {
+                merged[key] = localVal;
+            }
+            else if (rule === 'remote') {
+                merged[key] = remoteVal;
+            }
+            else {
+                const winner = rule === 'newer' ? 'newer' : defaultWinner;
+                if (winner === 'local') {
+                    merged[key] = localVal;
+                }
+                else if (winner === 'remote') {
+                    merged[key] = remoteVal;
+                }
+                else {
+                    // 'newer': compare timestamp
+                    merged[key] = localTime >= remoteTime ? localVal : remoteVal;
+                }
+            }
+        }
+        return { mergePayload: merged };
+    };
+}
 function getConflictResolver(strategyOrResolver) {
     if (typeof strategyOrResolver === 'function') {
         return strategyOrResolver;
@@ -31,6 +104,8 @@ function getConflictResolver(strategyOrResolver) {
             return exports.serverWinsResolver;
         case 'client-wins':
             return exports.clientWinsResolver;
+        case 'field-merge':
+            return createFieldMergeResolver();
         case 'last-write-wins':
         default:
             return exports.lastWriteWinsResolver;

package/dist/core/index.d.ts

@@ -8,6 +8,7 @@ export * from './meta-store.js';
 export * from './table-manager.js';
 export * from './schema-manager.js';
 export * from './query-builder.js';
+export * from './maintenance.js';
 export * from '../reactive/event-emitter.js';
 export * from '../adapters/network/index.js';
 export type { LocalDBAdapter, LocalTransaction } from '../adapters/local/index.js';

package/dist/core/index.js

@@ -25,6 +25,7 @@ __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("./maintenance.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/maintenance.d.ts

@@ -0,0 +1,66 @@
+import { LocalDBAdapter } from '../adapters/local/index.js';
+import { OutboxStatus } from './types.js';
+export interface PruneOutboxOptions {
+    /**
+     * Only delete outbox records older than this many days.
+     * e.g. retentionDays: 7 deletes records older than 7 days.
+     */
+    retentionDays?: number;
+    /**
+     * Explicit cutoff timestamp in milliseconds. Records older than this timestamp are eligible.
+     */
+    beforeTimestamp?: number;
+    /**
+     * Maximum number of outbox entries to retain. If the outbox exceeds this count,
+     * the oldest matching records are pruned.
+     */
+    maxEntries?: number;
+    /**
+     * Target statuses to prune. Defaults to ['COMPLETED', 'FAILED'].
+     * PENDING records are protected from pruning by default unless explicitly included.
+     */
+    statuses?: OutboxStatus[];
+}
+export interface OutboxStorageStats {
+    total: number;
+    pending: number;
+    processing: number;
+    completed: number;
+    failed: number;
+}
+export interface StorageStats {
+    /** Row count per table */
+    tables: Record<string, number>;
+    /** Breakdown of sync outbox items */
+    outbox: OutboxStorageStats;
+    /** SQLite allocation page size in bytes */
+    pageSize: number;
+    /** Total allocated SQLite database pages */
+    pageCount: number;
+    /** Total calculated database size on disk in bytes */
+    databaseSizeBytes: number;
+}
+export type CheckpointMode = 'PASSIVE' | 'FULL' | 'RESTART' | 'TRUNCATE';
+export declare class DatabaseMaintenance {
+    private readonly db;
+    private readonly getKnownTables;
+    constructor(db: LocalDBAdapter, getKnownTables?: () => string[]);
+    /**
+     * Reclaims unused space, defragments the database file, and optimizes internal B-trees.
+     */
+    vacuum(): Promise<void>;
+    /**
+     * Checkpoints WAL (Write-Ahead Log) pages into the main database file.
+     * 'TRUNCATE' (default) copies all WAL frames to the database file and resets WAL size to zero.
+     */
+    checkpoint(mode?: CheckpointMode): Promise<void>;
+    /**
+     * Prunes old or completed mutations from the sync_outbox table to keep database footprint small.
+     * Returns the count of deleted outbox records.
+     */
+    pruneOutbox(options?: PruneOutboxOptions): Promise<number>;
+    /**
+     * Gathers storage metrics: table row counts, outbox status distribution, and database size.
+     */
+    getStorageStats(): Promise<StorageStats>;
+}

package/dist/core/maintenance.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseMaintenance = void 0;
+const sql_js_1 = require("../utils/sql.js");
+class DatabaseMaintenance {
+    db;
+    getKnownTables;
+    constructor(db, getKnownTables = () => []) {
+        this.db = db;
+        this.getKnownTables = getKnownTables;
+    }
+    /**
+     * Reclaims unused space, defragments the database file, and optimizes internal B-trees.
+     */
+    async vacuum() {
+        await this.db.execute('VACUUM');
+    }
+    /**
+     * Checkpoints WAL (Write-Ahead Log) pages into the main database file.
+     * 'TRUNCATE' (default) copies all WAL frames to the database file and resets WAL size to zero.
+     */
+    async checkpoint(mode = 'TRUNCATE') {
+        await this.db.execute(`PRAGMA wal_checkpoint(${mode})`);
+    }
+    /**
+     * Prunes old or completed mutations from the sync_outbox table to keep database footprint small.
+     * Returns the count of deleted outbox records.
+     */
+    async pruneOutbox(options = {}) {
+        const statuses = options.statuses ?? ['COMPLETED', 'FAILED'];
+        if (statuses.length === 0)
+            return 0;
+        let cutoffTimestamp = options.beforeTimestamp;
+        if (options.retentionDays !== undefined && options.retentionDays >= 0) {
+            const daysMs = options.retentionDays * 24 * 60 * 60 * 1000;
+            const calculatedCutoff = Date.now() - daysMs;
+            cutoffTimestamp = cutoffTimestamp !== undefined
+                ? Math.min(cutoffTimestamp, calculatedCutoff)
+                : calculatedCutoff;
+        }
+        const conditions = [];
+        const params = [];
+        const statusPlaceholders = statuses.map(() => '?').join(', ');
+        conditions.push(`status IN (${statusPlaceholders})`);
+        params.push(...statuses);
+        if (cutoffTimestamp !== undefined) {
+            conditions.push('timestamp < ?');
+            params.push(cutoffTimestamp);
+        }
+        const whereClause = `WHERE ${conditions.join(' AND ')}`;
+        // If maxEntries is set, only prune if total matching exceeds maxEntries
+        if (options.maxEntries !== undefined && options.maxEntries >= 0) {
+            const countRes = await this.db.execute(`SELECT COUNT(*) as total FROM sync_outbox ${whereClause}`, params);
+            const totalMatching = Number(countRes[0]?.total ?? 0);
+            const excess = totalMatching - options.maxEntries;
+            if (excess <= 0) {
+                return 0;
+            }
+            // Delete the oldest `excess` records
+            const selectOldest = await this.db.execute(`SELECT id FROM sync_outbox ${whereClause} ORDER BY timestamp ASC LIMIT ?`, [...params, excess]);
+            if (selectOldest.length === 0)
+                return 0;
+            const ids = selectOldest.map((r) => r.id);
+            const idPlaceholders = ids.map(() => '?').join(', ');
+            await this.db.execute(`DELETE FROM sync_outbox WHERE id IN (${idPlaceholders})`, ids);
+            return ids.length;
+        }
+        // Standard cutoff delete
+        const beforeCountRes = await this.db.execute(`SELECT COUNT(*) as total FROM sync_outbox ${whereClause}`, params);
+        const toDeleteCount = Number(beforeCountRes[0]?.total ?? 0);
+        if (toDeleteCount === 0)
+            return 0;
+        await this.db.execute(`DELETE FROM sync_outbox ${whereClause}`, params);
+        return toDeleteCount;
+    }
+    /**
+     * Gathers storage metrics: table row counts, outbox status distribution, and database size.
+     */
+    async getStorageStats() {
+        // 1. Table row counts
+        const tableCounts = {};
+        let tableNames = [];
+        try {
+            const masterRows = await this.db.execute(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`);
+            tableNames = masterRows.map((r) => r.name);
+        }
+        catch {
+            tableNames = this.getKnownTables();
+        }
+        for (const tableName of tableNames) {
+            try {
+                const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+                const rows = await this.db.execute(`SELECT COUNT(*) as count FROM ${safeTable}`);
+                tableCounts[tableName] = Number(rows[0]?.count ?? 0);
+            }
+            catch {
+                // Table might not exist or be accessible
+            }
+        }
+        // 2. Outbox breakdown
+        const outboxStats = {
+            total: 0,
+            pending: 0,
+            processing: 0,
+            completed: 0,
+            failed: 0,
+        };
+        try {
+            const outboxRows = await this.db.execute(`SELECT status, COUNT(*) as count FROM sync_outbox GROUP BY status`);
+            for (const row of outboxRows) {
+                const st = String(row.status).toUpperCase();
+                const cnt = Number(row.count ?? 0);
+                outboxStats.total += cnt;
+                if (st === 'PENDING')
+                    outboxStats.pending = cnt;
+                else if (st === 'PROCESSING')
+                    outboxStats.processing = cnt;
+                else if (st === 'COMPLETED')
+                    outboxStats.completed = cnt;
+                else if (st === 'FAILED')
+                    outboxStats.failed = cnt;
+            }
+        }
+        catch {
+            // sync_outbox table may not exist yet
+        }
+        // 3. SQLite database sizing via PRAGMAs
+        let pageSize = 4096;
+        let pageCount = 0;
+        try {
+            const pageSizeRes = await this.db.execute('PRAGMA page_size');
+            if (pageSizeRes[0]) {
+                pageSize = Number(Object.values(pageSizeRes[0])[0] ?? 4096);
+            }
+        }
+        catch {
+            // fallback
+        }
+        try {
+            const pageCountRes = await this.db.execute('PRAGMA page_count');
+            if (pageCountRes[0]) {
+                pageCount = Number(Object.values(pageCountRes[0])[0] ?? 0);
+            }
+        }
+        catch {
+            // fallback
+        }
+        return {
+            tables: tableCounts,
+            outbox: outboxStats,
+            pageSize,
+            pageCount,
+            databaseSizeBytes: pageSize * pageCount,
+        };
+    }
+}
+exports.DatabaseMaintenance = DatabaseMaintenance;

package/dist/core/sync-worker.js

@@ -7,6 +7,7 @@ const outbox_store_js_1 = require("./outbox-store.js");
 const meta_store_js_1 = require("./meta-store.js");
 const table_manager_js_1 = require("./table-manager.js");
 const logger_js_1 = require("../utils/logger.js");
+const dynamic_js_1 = require("../utils/dynamic.js");
 const REACT_NATIVE_PKG = ['react', 'native'].join('-');
 /** Maximum outbox records sent per push cycle. */
 const PUSH_BATCH_SIZE = 50;
@@ -236,7 +237,8 @@ class SyncWorker {
             return false;
         // React Native AppState
         try {
-            const { AppState } = require('react-native');
+            const rn = (0, dynamic_js_1.safeDynamicRequire)(REACT_NATIVE_PKG);
+            const AppState = rn?.AppState;
             if (AppState?.currentState && typeof AppState.currentState === 'string') {
                 return Boolean(AppState.currentState.match(/inactive|background/));
             }
@@ -255,7 +257,8 @@ class SyncWorker {
             return;
         // 1. Try React Native AppState
         try {
-            const { AppState } = require('react-native');
+            const rn = (0, dynamic_js_1.safeDynamicRequire)(REACT_NATIVE_PKG);
+            const AppState = rn?.AppState;
             if (AppState && typeof AppState.addEventListener === 'function') {
                 const sub = AppState.addEventListener('change', (state) => {
                     if (state.match(/inactive|background/)) {
@@ -654,7 +657,7 @@ class SyncWorker {
                         }
                     }
                     // 3. Apply remote change to local database
-                    await table_manager_js_1.TableManager.applyMutation(tx, change.tableName, change.rowId, change.operation, change.payload, this.primaryKey, { autoSchema: this.autoSchema, schemaManager: this.schemaManager });
+                    await table_manager_js_1.TableManager.applyMutation(tx, change.tableName, change.rowId, change.operation, change.payload ?? null, this.primaryKey, { autoSchema: this.autoSchema, schemaManager: this.schemaManager });
                     // 4. Queue table change event to notify reactive listeners after commit
                     queuedEvents.push({
                         event: change.tableName,