local-lite 0.0.11 → 0.0.14

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,6 +2,7 @@ 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';
@@ -78,6 +79,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;

package/dist/core/client.js

@@ -6,6 +6,7 @@ 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");
@@ -156,6 +157,7 @@ class LocalFirstClient {
     autoHydrateJSON;
     /** Local column stamped on INSERT/UPDATE writes, or null when disabled. */
     touchColumn;
+    maintenance;
     primaryKey;
     migrations;
     autoStart;
@@ -180,6 +182,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,

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/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

@@ -654,7 +654,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,

package/dist/core/types.d.ts

@@ -5,7 +5,7 @@ export interface SyncOperation {
     tableName: string;
     rowId: string;
     operation: SyncOp;
-    payload: Record<string, any> | null;
+    payload?: Record<string, any> | null;
     timestamp: number;
 }
 export interface PushResult {
@@ -16,14 +16,14 @@ export interface PushResult {
 }
 export interface OutboxRecord extends SyncOperation {
     status: OutboxStatus;
-    retryCount: number;
+    retryCount?: number;
     lastError?: string | null;
 }
 export interface DeltaChange {
     tableName: string;
     operation: SyncOp;
     rowId: string;
-    payload: Record<string, any> | null;
+    payload?: Record<string, any> | null;
     timestamp?: number;
 }
 export interface DeltaChanges {
@@ -41,7 +41,37 @@ export interface ConflictContext {
     localRow?: Record<string, any> | null;
 }
 export type ConflictResolver = (context: ConflictContext) => ConflictResolution | Promise<ConflictResolution>;
-export type ConflictStrategy = 'last-write-wins' | 'server-wins' | 'client-wins';
+export type ConflictStrategy = 'last-write-wins' | 'server-wins' | 'client-wins' | 'field-merge';
+export type FieldMergeWinner = 'remote' | 'local' | 'newer' | 'max' | 'min';
+export type FieldMergeCustomResolver = (localVal: any, remoteVal: any, context: ConflictContext) => any;
+export type FieldMergeRule = FieldMergeWinner | FieldMergeCustomResolver;
+export interface FieldMergeResolverOptions {
+    /**
+     * Default resolution strategy when both local and remote updated the exact same field.
+     * 'newer' (default) uses timestamp to pick the newer field; 'remote' or 'local' picks fixed side.
+     */
+    defaultWinner?: 'remote' | 'local' | 'newer';
+    /**
+     * Field-level merge rules by table and column.
+     * e.g.
+     * {
+     *   notes: {
+     *     tags: (local, remote) => Array.from(new Set([...(local ?? []), ...(remote ?? [])])),
+     *     view_count: 'max',
+     *   },
+     *   '*': {
+     *     updated_at: 'newer'
+     *   }
+     * }
+     */
+    fieldRules?: Record<string, Record<string, FieldMergeRule>>;
+    /**
+     * Strategy when one side deleted the row while the other side updated fields.
+     * 'delete-wins' (default) preserves the deletion.
+     * 'update-wins' resurrects the row with the updated fields.
+     */
+    deleteHandling?: 'delete-wins' | 'update-wins';
+}
 export interface NetworkStatusProvider {
     isOnline(): boolean | Promise<boolean>;
     subscribe(callback: (isOnline: boolean) => void): () => void;

package/dist/index.d.ts

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

package/dist/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./core/meta-store.js"), exports);
 __exportStar(require("./core/table-manager.js"), exports);
 __exportStar(require("./core/schema-manager.js"), exports);
 __exportStar(require("./core/query-builder.js"), exports);
+__exportStar(require("./core/maintenance.js"), exports);
 __exportStar(require("./reactive/event-emitter.js"), exports);
 __exportStar(require("./adapters/local/index.js"), exports);
 __exportStar(require("./adapters/remote/index.js"), exports);
@@ -32,4 +33,7 @@ __exportStar(require("./config/index.js"), exports);
 __exportStar(require("./utils/uuid.js"), exports);
 __exportStar(require("./utils/sql.js"), exports);
 __exportStar(require("./utils/logger.js"), exports);
+__exportStar(require("./utils/portability.js"), exports);
 __exportStar(require("./schema/index.js"), exports);
+__exportStar(require("./auth/index.js"), exports);
+__exportStar(require("./backups/index.js"), exports);

package/dist/react/auth.d.ts

@@ -0,0 +1,46 @@
+import type { GoogleAuthClient, GoogleUser } from '../auth/google.js';
+import type { MicrosoftAuthClient, MicrosoftUser } from '../auth/microsoft.js';
+import type { GitHubAuthClient, GitHubUser } from '../auth/github.js';
+import type { AppleAuthClient, AppleUser, AppleNativeCredential } from '../auth/apple.js';
+export interface UseGoogleAuthResult {
+    user: GoogleUser | null;
+    isSignedIn: boolean;
+    loading: boolean;
+    error: Error | null;
+    signIn: () => Promise<GoogleUser | null>;
+    signOut: () => Promise<void>;
+    refetchUser: () => Promise<GoogleUser | null>;
+}
+export declare function useGoogleAuth(client: GoogleAuthClient | null | undefined): UseGoogleAuthResult;
+export interface UseMicrosoftAuthResult {
+    user: MicrosoftUser | null;
+    isSignedIn: boolean;
+    loading: boolean;
+    error: Error | null;
+    signIn: () => Promise<MicrosoftUser | null>;
+    signOut: () => Promise<void>;
+    refetchUser: () => Promise<MicrosoftUser | null>;
+}
+export type UseOneDriveAuthResult = UseMicrosoftAuthResult;
+export declare function useMicrosoftAuth(client: MicrosoftAuthClient | null | undefined): UseMicrosoftAuthResult;
+export declare const useOneDriveAuth: typeof useMicrosoftAuth;
+export interface UseGitHubAuthResult {
+    user: GitHubUser | null;
+    isSignedIn: boolean;
+    loading: boolean;
+    error: Error | null;
+    signIn: () => Promise<GitHubUser | null>;
+    signOut: () => Promise<void>;
+    refetchUser: () => Promise<GitHubUser | null>;
+}
+export declare function useGitHubAuth(client: GitHubAuthClient | null | undefined): UseGitHubAuthResult;
+export interface UseAppleAuthResult {
+    user: AppleUser | null;
+    isSignedIn: boolean;
+    loading: boolean;
+    error: Error | null;
+    signIn: (nativeCredential?: AppleNativeCredential) => Promise<AppleUser | null>;
+    signOut: () => Promise<void>;
+    refetchUser: () => Promise<AppleUser | null>;
+}
+export declare function useAppleAuth(client: AppleAuthClient | null | undefined): UseAppleAuthResult;