@pol-studios/powersync 1.0.6 → 1.0.10

package/dist/connector/index.d.ts

@@ -1,5 +1,237 @@
-export { f as ConflictBus, C as ConnectorConfig, c as CrudHandler, D as DEFAULT_RETRY_CONFIG, P as PowerSyncCredentials, e as RetryConfig, R as RetryStrategyConfig, b as SchemaRouter, S as SupabaseConnector, a as SupabaseConnectorOptions, d as defaultSchemaRouter } from '../index-l3iL9Jte.js';
-export { P as PowerSyncBackendConnector } from '../types-afHtE1U_.js';
-import '@supabase/supabase-js';
+import { A as AuthProvider } from '../types-B212hgfA.js';
+export { g as ConflictBus, C as ConnectorCircuitBreakerConfig, a as ConnectorConfig, c as CrudHandler, D as DEFAULT_RETRY_CONFIG, P as PowerSyncCredentials, e as RetryConfig, R as RetryStrategyConfig, b as SchemaRouter, f as Session, S as SupabaseConnectorOptions, d as defaultSchemaRouter } from '../types-B212hgfA.js';
+export { S as SupabaseConnector } from '../supabase-connector-T9vHq_3i.js';
+import { SupabaseClient } from '@supabase/supabase-js';
+export { P as PowerSyncBackendConnector } from '../types-CDqWh56B.js';
 import '../platform/index.js';
-import '../failed-upload-store-C0cLxxPz.js';
+
+/**
+ * Supabase Auth Provider for @pol-studios/powersync
+ *
+ * Factory function that wraps a Supabase client's auth methods
+ * to implement the AuthProvider interface.
+ */
+
+/**
+ * Options for createSupabaseAuth
+ */
+interface SupabaseAuthOptions {
+    /**
+     * Called when a session refresh fails.
+     * Use this to trigger logout flows or show error UI.
+     */
+    onRefreshError?: (error: Error) => void;
+}
+/**
+ * Creates an AuthProvider that wraps Supabase auth.
+ *
+ * @param supabase - Supabase client instance
+ * @param options - Optional configuration
+ * @returns AuthProvider implementation
+ *
+ * @example
+ * ```typescript
+ * import { createSupabaseAuth } from '@pol-studios/powersync';
+ *
+ * const auth = createSupabaseAuth(supabaseClient, {
+ *   onRefreshError: (error) => {
+ *     console.error('Session refresh failed:', error);
+ *     // Navigate to login screen
+ *   },
+ * });
+ *
+ * // Use with PowerSyncProvider
+ * <PowerSyncProvider auth={auth} ... />
+ * ```
+ */
+declare function createSupabaseAuth(supabase: SupabaseClient, options?: SupabaseAuthOptions): AuthProvider;
+/**
+ * Error thrown when session refresh fails.
+ */
+declare class AuthRefreshError extends Error {
+    readonly name = "AuthRefreshError";
+    readonly cause?: Error;
+    constructor(message: string, options?: {
+        cause?: Error;
+    });
+}
+
+/**
+ * Circuit Breaker Pattern for PowerSync Connector
+ *
+ * Prevents cascading failures by temporarily stopping requests when
+ * a service is experiencing high failure rates.
+ *
+ * States:
+ * - CLOSED: Normal operation, requests flow through
+ * - OPEN: Service is failing, requests are blocked
+ * - HALF_OPEN: Testing if service has recovered
+ *
+ * Transitions:
+ * - CLOSED -> OPEN: After failureThreshold failures within failureWindowMs
+ * - OPEN -> HALF_OPEN: After timeout (exponential backoff)
+ * - HALF_OPEN -> CLOSED: On successful request
+ * - HALF_OPEN -> OPEN: On failed request (with reset backoff multiplier)
+ */
+/**
+ * Circuit breaker states
+ */
+type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+/**
+ * Configuration for the circuit breaker
+ */
+interface CircuitBreakerConfig {
+    /**
+     * Number of failures required to trip the circuit
+     * @default 5
+     */
+    failureThreshold: number;
+    /**
+     * Time window in ms for counting failures
+     * @default 60000 (60 seconds)
+     */
+    failureWindowMs: number;
+    /**
+     * Initial delay before transitioning from OPEN to HALF_OPEN
+     * @default 1000 (1 second)
+     */
+    initialRecoveryDelayMs: number;
+    /**
+     * Maximum delay for exponential backoff
+     * @default 32000 (32 seconds)
+     */
+    maxRecoveryDelayMs: number;
+    /**
+     * Multiplier for exponential backoff
+     * @default 2
+     */
+    backoffMultiplier: number;
+    /**
+     * Optional callback when state changes
+     */
+    onStateChange?: (state: CircuitState, previousState: CircuitState) => void;
+    /**
+     * Optional logger
+     */
+    logger?: {
+        debug: (...args: unknown[]) => void;
+        info: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+    };
+}
+/**
+ * Default circuit breaker configuration
+ */
+declare const DEFAULT_CIRCUIT_BREAKER_CONFIG: CircuitBreakerConfig;
+/**
+ * Statistics about the circuit breaker state
+ */
+interface CircuitBreakerStats {
+    /** Current state */
+    state: CircuitState;
+    /** Number of failures in current window */
+    failureCount: number;
+    /** Number of successful requests since last state change */
+    successCount: number;
+    /** Number of times circuit has opened */
+    openCount: number;
+    /** Time when circuit last opened */
+    lastOpenedAt: Date | null;
+    /** Time when circuit last closed */
+    lastClosedAt: Date | null;
+    /** Current recovery delay (when OPEN) */
+    currentRecoveryDelayMs: number;
+    /** Time until next HALF_OPEN attempt (when OPEN) */
+    timeUntilHalfOpenMs: number | null;
+}
+/**
+ * Error thrown when circuit is open
+ */
+declare class CircuitOpenError extends Error {
+    readonly timeUntilRetryMs: number;
+    readonly stats: CircuitBreakerStats;
+    constructor(timeUntilRetryMs: number, stats: CircuitBreakerStats);
+}
+/**
+ * Circuit Breaker implementation
+ *
+ * @example
+ * ```typescript
+ * const breaker = new CircuitBreaker({
+ *   failureThreshold: 5,
+ *   failureWindowMs: 60000,
+ *   onStateChange: (state) => console.log('Circuit state:', state),
+ * });
+ *
+ * // Wrap your async operations
+ * try {
+ *   const result = await breaker.execute(() => fetchData());
+ * } catch (error) {
+ *   if (error instanceof CircuitOpenError) {
+ *     console.log('Service unavailable, retry later');
+ *   }
+ * }
+ * ```
+ */
+declare class CircuitBreaker {
+    private state;
+    private failures;
+    private successCount;
+    private openCount;
+    private lastOpenedAt;
+    private lastClosedAt;
+    private currentRecoveryDelay;
+    private halfOpenTimer;
+    private halfOpenScheduledAt;
+    private readonly config;
+    constructor(config?: Partial<CircuitBreakerConfig>);
+    /**
+     * Get current state
+     */
+    getState(): CircuitState;
+    /**
+     * Get circuit breaker statistics
+     */
+    getStats(): CircuitBreakerStats;
+    /**
+     * Check if requests are allowed through the circuit
+     */
+    isAllowed(): boolean;
+    /**
+     * Check if request can proceed, throws if not
+     */
+    checkAllowed(): void;
+    /**
+     * Record a successful operation
+     */
+    recordSuccess(): void;
+    /**
+     * Record a failed operation
+     */
+    recordFailure(): void;
+    /**
+     * Execute an async operation through the circuit breaker
+     */
+    execute<T>(operation: () => Promise<T>): Promise<T>;
+    /**
+     * Manually reset the circuit breaker to CLOSED state
+     */
+    reset(): void;
+    /**
+     * Force the circuit to OPEN state (e.g., for manual intervention)
+     */
+    forceOpen(): void;
+    /**
+     * Dispose the circuit breaker (clear timers)
+     */
+    dispose(): void;
+    private transition;
+    private scheduleHalfOpen;
+    private clearHalfOpenTimer;
+    private getTimeUntilHalfOpen;
+    private cleanupOldFailures;
+    private log;
+}
+
+export { AuthProvider, AuthRefreshError, CircuitBreaker, type CircuitBreakerConfig, type CircuitBreakerStats, CircuitOpenError, type CircuitState, DEFAULT_CIRCUIT_BREAKER_CONFIG, type SupabaseAuthOptions, createSupabaseAuth };

package/dist/connector/index.js

@@ -1,14 +1,25 @@
-import "../chunk-VJCL2SWD.js";
+import {
+  AuthRefreshError,
+  CircuitBreaker,
+  CircuitOpenError,
+  DEFAULT_CIRCUIT_BREAKER_CONFIG,
+  createSupabaseAuth
+} from "../chunk-HWSNV45P.js";
 import {
   DEFAULT_RETRY_CONFIG,
   SupabaseConnector,
   defaultSchemaRouter
-} from "../chunk-62J2DPKX.js";
-import "../chunk-PAFBKNL3.js";
-import "../chunk-FPTDATY5.js";
+} from "../chunk-KN2IZERF.js";
+import "../chunk-FV2HXEIY.js";
+import "../chunk-VACPAAQZ.js";
 export {
+  AuthRefreshError,
+  CircuitBreaker,
+  CircuitOpenError,
+  DEFAULT_CIRCUIT_BREAKER_CONFIG,
   DEFAULT_RETRY_CONFIG,
   SupabaseConnector,
+  createSupabaseAuth,
   defaultSchemaRouter
 };
 //# sourceMappingURL=index.js.map

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
-import { g as SyncErrorType, i as ClassifiedError, f as SyncError, C as CrudEntry } from '../types-afHtE1U_.js';
-export { A as AbstractPowerSyncDatabase, k as CacheStats, j as CompactResult, h as CompletedTransaction, b as ConnectionHealth, o as CountRow, l as CrudTransaction, n as DbStatRow, D as DownloadProgress, E as EntitySyncState, F as FailedTransaction, r as FreelistCountRow, s as IntegrityCheckRow, I as IntegrityResult, q as PageCountRow, p as PageSizeRow, P as PowerSyncBackendConnector, m as SqliteTableRow, c as StorageInfo, d as StorageQuota, e as SyncMetrics, S as SyncMode, a as SyncStatus, T as TableCacheStats } from '../types-afHtE1U_.js';
+import { g as SyncErrorType, i as ClassifiedError, f as SyncError, C as CrudEntry } from '../types-CDqWh56B.js';
+export { A as AbstractPowerSyncDatabase, k as CacheStats, j as CompactResult, h as CompletedTransaction, b as ConnectionHealth, o as CountRow, l as CrudTransaction, n as DbStatRow, D as DownloadProgress, E as EntitySyncState, F as FailedTransaction, r as FreelistCountRow, s as IntegrityCheckRow, I as IntegrityResult, q as PageCountRow, p as PageSizeRow, P as PowerSyncBackendConnector, m as SqliteTableRow, c as StorageInfo, d as StorageQuota, e as SyncMetrics, S as SyncMode, a as SyncStatus, T as TableCacheStats } from '../types-CDqWh56B.js';
 
 /**
  * Constants for @pol-studios/powersync
@@ -19,6 +19,8 @@ declare const STORAGE_KEY_METRICS = "@pol-studios/powersync-metrics";
 declare const STORAGE_KEY_ATTACHMENT_SETTINGS = "@pol-studios/powersync-attachment-settings";
 /** Storage key for sync mode */
 declare const STORAGE_KEY_SYNC_MODE = "@pol-studios/powersync-sync-mode";
+/** Storage key for auto-offline flag (tracks if offline was set automatically vs manually) */
+declare const STORAGE_KEY_AUTO_OFFLINE = "@pol-studios/powersync-auto-offline";
 /** Default sync mode */
 declare const DEFAULT_SYNC_MODE: "push-pull";
 /** Interval between health checks in milliseconds */
@@ -193,5 +195,16 @@ declare function extractEntityIds(entries: CrudEntry[]): string[];
  * Extract unique table names from CRUD entries.
  */
 declare function extractTableNames(entries: CrudEntry[]): string[];
+/**
+ * Check if an error is an RLS/permission error (PostgreSQL 42501 - insufficient_privilege).
+ *
+ * RLS errors are special because they may resolve when parent data syncs.
+ * For example, inserting a child record may fail until the parent record syncs
+ * and satisfies the RLS policy conditions.
+ *
+ * @param error - The error to check
+ * @returns true if the error is an RLS/permission error
+ */
+declare function isRlsError(error: unknown): boolean;
 
-export { ATTACHMENT_DOWNLOAD_TIMEOUT_MS, ATTACHMENT_RETRY_DELAY_MS, AttachmentError, COMPRESSION_MAX_WIDTH, COMPRESSION_SKIP_SIZE_BYTES, COMPRESSION_TARGET_SIZE_BYTES, ClassifiedError, ConfigurationError, ConnectorError, CrudEntry, DEFAULT_ATTACHMENT_CACHE_SIZE, DEFAULT_ATTACHMENT_CONCURRENCY, DEFAULT_COMPRESSION_QUALITY, DEFAULT_MAX_RETRY_ATTEMPTS, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_BASE_DELAY_MS, DEFAULT_RETRY_MAX_DELAY_MS, DEFAULT_SYNC_INTERVAL_MS, DEFAULT_SYNC_MODE, DOWNLOAD_STOP_THRESHOLD, EVICTION_TRIGGER_THRESHOLD, HEALTH_CHECK_INTERVAL_MS, HEALTH_CHECK_TIMEOUT_MS, InitializationError, LATENCY_DEGRADED_THRESHOLD_MS, MAX_CONSECUTIVE_FAILURES, PlatformAdapterError, PowerSyncError, STATS_CACHE_TTL_MS, STATUS_NOTIFY_THROTTLE_MS, STORAGE_CRITICAL_THRESHOLD, STORAGE_KEY_ATTACHMENT_SETTINGS, STORAGE_KEY_ENABLED, STORAGE_KEY_METRICS, STORAGE_KEY_PAUSED, STORAGE_KEY_PREFIX, STORAGE_KEY_SYNC_MODE, STORAGE_WARNING_THRESHOLD, SyncError, SyncErrorType, SyncOperationError, classifyError, classifySupabaseError, createSyncError, extractEntityIds, extractTableNames, generateFailureId, toSyncOperationError };
+export { ATTACHMENT_DOWNLOAD_TIMEOUT_MS, ATTACHMENT_RETRY_DELAY_MS, AttachmentError, COMPRESSION_MAX_WIDTH, COMPRESSION_SKIP_SIZE_BYTES, COMPRESSION_TARGET_SIZE_BYTES, ClassifiedError, ConfigurationError, ConnectorError, CrudEntry, DEFAULT_ATTACHMENT_CACHE_SIZE, DEFAULT_ATTACHMENT_CONCURRENCY, DEFAULT_COMPRESSION_QUALITY, DEFAULT_MAX_RETRY_ATTEMPTS, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_BASE_DELAY_MS, DEFAULT_RETRY_MAX_DELAY_MS, DEFAULT_SYNC_INTERVAL_MS, DEFAULT_SYNC_MODE, DOWNLOAD_STOP_THRESHOLD, EVICTION_TRIGGER_THRESHOLD, HEALTH_CHECK_INTERVAL_MS, HEALTH_CHECK_TIMEOUT_MS, InitializationError, LATENCY_DEGRADED_THRESHOLD_MS, MAX_CONSECUTIVE_FAILURES, PlatformAdapterError, PowerSyncError, STATS_CACHE_TTL_MS, STATUS_NOTIFY_THROTTLE_MS, STORAGE_CRITICAL_THRESHOLD, STORAGE_KEY_ATTACHMENT_SETTINGS, STORAGE_KEY_AUTO_OFFLINE, STORAGE_KEY_ENABLED, STORAGE_KEY_METRICS, STORAGE_KEY_PAUSED, STORAGE_KEY_PREFIX, STORAGE_KEY_SYNC_MODE, STORAGE_WARNING_THRESHOLD, SyncError, SyncErrorType, SyncOperationError, classifyError, classifySupabaseError, createSyncError, extractEntityIds, extractTableNames, generateFailureId, isRlsError, toSyncOperationError };

package/dist/core/index.js

@@ -24,13 +24,14 @@ import {
   STATUS_NOTIFY_THROTTLE_MS,
   STORAGE_CRITICAL_THRESHOLD,
   STORAGE_KEY_ATTACHMENT_SETTINGS,
+  STORAGE_KEY_AUTO_OFFLINE,
   STORAGE_KEY_ENABLED,
   STORAGE_KEY_METRICS,
   STORAGE_KEY_PAUSED,
   STORAGE_KEY_PREFIX,
   STORAGE_KEY_SYNC_MODE,
   STORAGE_WARNING_THRESHOLD
-} from "../chunk-EJ23MXPQ.js";
+} from "../chunk-CGL33PL4.js";
 import {
   AttachmentError,
   ConfigurationError,
@@ -45,8 +46,9 @@ import {
   extractEntityIds,
   extractTableNames,
   generateFailureId,
+  isRlsError,
   toSyncOperationError
-} from "../chunk-FPTDATY5.js";
+} from "../chunk-VACPAAQZ.js";
 export {
   ATTACHMENT_DOWNLOAD_TIMEOUT_MS,
   ATTACHMENT_RETRY_DELAY_MS,
@@ -78,6 +80,7 @@ export {
   STATUS_NOTIFY_THROTTLE_MS,
   STORAGE_CRITICAL_THRESHOLD,
   STORAGE_KEY_ATTACHMENT_SETTINGS,
+  STORAGE_KEY_AUTO_OFFLINE,
   STORAGE_KEY_ENABLED,
   STORAGE_KEY_METRICS,
   STORAGE_KEY_PAUSED,
@@ -91,6 +94,7 @@ export {
   extractEntityIds,
   extractTableNames,
   generateFailureId,
+  isRlsError,
   toSyncOperationError
 };
 //# sourceMappingURL=index.js.map

package/dist/error/index.d.ts

@@ -0,0 +1,54 @@
+import { Component, ReactNode } from 'react';
+
+interface PowerSyncErrorBoundaryProps {
+    children: ReactNode;
+    /**
+     * Custom fallback UI when an error occurs.
+     * Must be provided since there is no platform-agnostic default.
+     */
+    fallback: (error: Error, retry: () => void) => ReactNode;
+    /**
+     * Callback when an error is caught.
+     */
+    onError?: (error: Error) => void;
+}
+interface PowerSyncErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+    retryKey: number;
+}
+/**
+ * Error boundary for PowerSync initialization errors.
+ *
+ * Catches errors during PowerSync initialization and provides
+ * a retry mechanism to attempt reinitialization.
+ *
+ * Note: The fallback prop is required because there is no
+ * platform-agnostic default UI.
+ *
+ * @example
+ * ```tsx
+ * <PowerSyncErrorBoundary
+ *   fallback={(error, retry) => (
+ *     <View>
+ *       <Text>Error: {error.message}</Text>
+ *       <Button onPress={retry}>Retry</Button>
+ *     </View>
+ *   )}
+ *   onError={(error) => console.error('PowerSync error:', error)}
+ * >
+ *   <PowerSyncProvider config={config}>
+ *     <App />
+ *   </PowerSyncProvider>
+ * </PowerSyncErrorBoundary>
+ * ```
+ */
+declare class PowerSyncErrorBoundary extends Component<PowerSyncErrorBoundaryProps, PowerSyncErrorBoundaryState> {
+    constructor(props: PowerSyncErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): Partial<PowerSyncErrorBoundaryState>;
+    componentDidCatch(error: Error): void;
+    handleRetry: () => void;
+    render(): ReactNode;
+}
+
+export { PowerSyncErrorBoundary };

package/dist/error/index.js

@@ -0,0 +1,7 @@
+import {
+  PowerSyncErrorBoundary
+} from "../chunk-P6WOZO7H.js";
+export {
+  PowerSyncErrorBoundary
+};
+//# sourceMappingURL=index.js.map

package/dist/error/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -1,17 +1,29 @@
-import { A as AbstractPowerSyncDatabase } from './types-afHtE1U_.js';
-export { k as CacheStats, i as ClassifiedError, j as CompactResult, h as CompletedTransaction, b as ConnectionHealth, o as CountRow, C as CrudEntry, l as CrudTransaction, n as DbStatRow, D as DownloadProgress, E as EntitySyncState, F as FailedTransaction, r as FreelistCountRow, s as IntegrityCheckRow, I as IntegrityResult, q as PageCountRow, p as PageSizeRow, P as PowerSyncBackendConnector, m as SqliteTableRow, c as StorageInfo, d as StorageQuota, f as SyncError, g as SyncErrorType, e as SyncMetrics, S as SyncMode, a as SyncStatus, T as TableCacheStats } from './types-afHtE1U_.js';
-export { ATTACHMENT_DOWNLOAD_TIMEOUT_MS, ATTACHMENT_RETRY_DELAY_MS, AttachmentError, COMPRESSION_MAX_WIDTH, COMPRESSION_SKIP_SIZE_BYTES, COMPRESSION_TARGET_SIZE_BYTES, ConfigurationError, ConnectorError, DEFAULT_ATTACHMENT_CACHE_SIZE, DEFAULT_ATTACHMENT_CONCURRENCY, DEFAULT_COMPRESSION_QUALITY, DEFAULT_MAX_RETRY_ATTEMPTS, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_BASE_DELAY_MS, DEFAULT_RETRY_MAX_DELAY_MS, DEFAULT_SYNC_INTERVAL_MS, DEFAULT_SYNC_MODE, DOWNLOAD_STOP_THRESHOLD, EVICTION_TRIGGER_THRESHOLD, HEALTH_CHECK_INTERVAL_MS, HEALTH_CHECK_TIMEOUT_MS, InitializationError, LATENCY_DEGRADED_THRESHOLD_MS, MAX_CONSECUTIVE_FAILURES, PlatformAdapterError, PowerSyncError, STATS_CACHE_TTL_MS, STATUS_NOTIFY_THROTTLE_MS, STORAGE_CRITICAL_THRESHOLD, STORAGE_KEY_ATTACHMENT_SETTINGS, STORAGE_KEY_ENABLED, STORAGE_KEY_METRICS, STORAGE_KEY_PAUSED, STORAGE_KEY_PREFIX, STORAGE_KEY_SYNC_MODE, STORAGE_WARNING_THRESHOLD, SyncOperationError, classifyError, classifySupabaseError, createSyncError, extractEntityIds, extractTableNames, generateFailureId, toSyncOperationError } from './core/index.js';
-import { j as ConflictDetectionConfig, g as ConflictCheckResult } from './index-l3iL9Jte.js';
-export { f as ConflictBus, i as ConflictHandler, k as ConflictListener, h as ConflictResolution, C as ConnectorConfig, c as CrudHandler, D as DEFAULT_RETRY_CONFIG, F as FieldConflict, P as PowerSyncCredentials, l as ResolutionListener, e as RetryConfig, R as RetryStrategyConfig, b as SchemaRouter, S as SupabaseConnector, a as SupabaseConnectorOptions, d as defaultSchemaRouter } from './index-l3iL9Jte.js';
-export { AttachmentQueue, AttachmentQueueConfig, AttachmentRecord, AttachmentSourceConfig, AttachmentState, AttachmentStatsRow, AttachmentStorageAdapter, AttachmentSyncStats, AttachmentSyncStatus, CacheConfig, CacheFileRow, CachedSizeRow, CompressionConfig, DEFAULT_CACHE_CONFIG, DEFAULT_COMPRESSION_CONFIG, DEFAULT_DOWNLOAD_CONFIG, DownloadConfig, DownloadPhase, DownloadStatus, EvictRow, IdRow } from './attachments/index.js';
-export { e as HealthCheckResult, H as HealthMonitorOptions, M as MetricsCollectorOptions, P as PowerSyncRawStatus, c as SyncControlActions, f as SyncEvent, g as SyncEventListener, d as SyncOperationData, S as SyncScope, a as SyncStatusState, b as SyncStatusTrackerOptions, U as Unsubscribe } from './types-Cd7RhNqf.js';
-export { HealthMonitor, MetricsCollector, SyncStatusTracker } from './sync/index.js';
-export { F as FailedUpload, a as FailedUploadStore, f as failedUploadStore } from './failed-upload-store-C0cLxxPz.js';
+import { A as AbstractPowerSyncDatabase } from './types-CDqWh56B.js';
+export { k as CacheStats, i as ClassifiedError, j as CompactResult, h as CompletedTransaction, b as ConnectionHealth, o as CountRow, C as CrudEntry, l as CrudTransaction, n as DbStatRow, D as DownloadProgress, E as EntitySyncState, F as FailedTransaction, r as FreelistCountRow, s as IntegrityCheckRow, I as IntegrityResult, q as PageCountRow, p as PageSizeRow, P as PowerSyncBackendConnector, m as SqliteTableRow, c as StorageInfo, d as StorageQuota, f as SyncError, g as SyncErrorType, e as SyncMetrics, S as SyncMode, a as SyncStatus, T as TableCacheStats } from './types-CDqWh56B.js';
+export { ATTACHMENT_DOWNLOAD_TIMEOUT_MS, ATTACHMENT_RETRY_DELAY_MS, AttachmentError, COMPRESSION_MAX_WIDTH, COMPRESSION_SKIP_SIZE_BYTES, COMPRESSION_TARGET_SIZE_BYTES, ConfigurationError, ConnectorError, DEFAULT_ATTACHMENT_CACHE_SIZE, DEFAULT_ATTACHMENT_CONCURRENCY, DEFAULT_COMPRESSION_QUALITY, DEFAULT_MAX_RETRY_ATTEMPTS, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_BASE_DELAY_MS, DEFAULT_RETRY_MAX_DELAY_MS, DEFAULT_SYNC_INTERVAL_MS, DEFAULT_SYNC_MODE, DOWNLOAD_STOP_THRESHOLD, EVICTION_TRIGGER_THRESHOLD, HEALTH_CHECK_INTERVAL_MS, HEALTH_CHECK_TIMEOUT_MS, InitializationError, LATENCY_DEGRADED_THRESHOLD_MS, MAX_CONSECUTIVE_FAILURES, PlatformAdapterError, PowerSyncError, STATS_CACHE_TTL_MS, STATUS_NOTIFY_THROTTLE_MS, STORAGE_CRITICAL_THRESHOLD, STORAGE_KEY_ATTACHMENT_SETTINGS, STORAGE_KEY_AUTO_OFFLINE, STORAGE_KEY_ENABLED, STORAGE_KEY_METRICS, STORAGE_KEY_PAUSED, STORAGE_KEY_PREFIX, STORAGE_KEY_SYNC_MODE, STORAGE_WARNING_THRESHOLD, SyncOperationError, classifyError, classifySupabaseError, createSyncError, extractEntityIds, extractTableNames, generateFailureId, isRlsError, toSyncOperationError } from './core/index.js';
+import { k as ConflictDetectionConfig, h as ConflictCheckResult } from './types-B212hgfA.js';
+export { A as AuthProvider, g as ConflictBus, j as ConflictHandler, l as ConflictListener, i as ConflictResolution, C as ConnectorCircuitBreakerConfig, a as ConnectorConfig, c as CrudHandler, D as DEFAULT_RETRY_CONFIG, F as FieldConflict, P as PowerSyncCredentials, m as ResolutionListener, e as RetryConfig, R as RetryStrategyConfig, b as SchemaRouter, f as Session, S as SupabaseConnectorOptions, d as defaultSchemaRouter } from './types-B212hgfA.js';
+export { S as SupabaseConnector } from './supabase-connector-T9vHq_3i.js';
+export { AuthRefreshError, CircuitBreaker, CircuitBreakerConfig, CircuitBreakerStats, CircuitOpenError, CircuitState, DEFAULT_CIRCUIT_BREAKER_CONFIG, SupabaseAuthOptions, createSupabaseAuth } from './connector/index.js';
+export { e as AttachmentConfig, z as AttachmentRecord, A as AttachmentSourceConfig, w as AttachmentStatsRow, f as AttachmentStorageAdapter, v as AttachmentSyncStats, u as AttachmentSyncStatus, B as BatchFilterContext, m as CACHE_SIZE_PRESETS, k as CacheConfig, x as CacheFileRow, n as CacheSizePreset, o as CacheSizeValue, y as CachedSizeRow, C as CompressionConfig, l as DEFAULT_CACHE_CONFIG, D as DEFAULT_COMPRESSION_CONFIG, j as DEFAULT_DOWNLOAD_CONFIG, g as DEFAULT_UPLOAD_CONFIG, i as DownloadConfig, q as DownloadPhase, r as DownloadStatus, E as EvictRow, I as IdRow, P as PolAttachmentQueue, a as PolAttachmentQueueOptions, d as PolAttachmentRecord, b as PolAttachmentState, S as SkipDownloadContext, U as UploadConfig, h as UploadHandler, s as UploadPhase, t as UploadStatus, W as WatchConfig, c as createPolAttachmentQueue, p as formatCacheSize } from './pol-attachment-queue-BVAIueoP.js';
+export { CacheManagerDeps, DOWNLOAD_WORKFLOW_STATES, DownloadManagerDeps, LOCALLY_AVAILABLE_STATES, MigrationStats, PENDING_DOWNLOAD_STATES, PROTECTED_UPLOAD_STATES, PolStorageAdapter, PolStorageAdapterOptions, STATE_MAPPING, STATE_NAMES, TERMINAL_STATES, UPLOAD_WORKFLOW_STATES, UploadManagerDeps, UploadManagerState, VALID_STATES, blobToArrayBuffer, buildIdOnlyWatchQuery, buildRecordFetchQuery, buildWatchQuery, cacheLocalFile, clearCache, clearUploadCallback, copyToManagedCache, createCacheManagerDeps, createMigrationStats, createUploadManagerDeps, createUploadManagerState, determineAttachmentState, downloadRecord, enforceCacheLimit, ensureFileUri, extractErrorCode, formatMigrationStats, getCachedSize, getEvictionCandidates, getExcludeProtectedStatesCondition, getFailedPermanentUploads, getLocalUriForStoragePath, getPendingUploads, getProtectedStatesInClause, getSoonestRetryTime, getStaleUploads, getStateName, getSyncedUploadsWithPendingCallback, isCacheNearCapacity, isDownloadWorkflowState, isLocallyAvailable, isPendingDownloadState, isPermanentError, isProtectedUploadState, isStateTransitionAllowed, isTerminalState, isUploadWorkflowState, isValidAttachmentState, markUploadPermanentFailure, markUploadSynced, migrateAttachmentState, migrateAttachmentStateSafe, recordMigration, scheduleUploadRetry, startUploadProcessing, stripFileUri, uploadOne, validateSqlIdentifier, validateSqlIdentifierFromStateMachine, validateWhereClause, watchConfigToSourceConfig } from './attachments/index.js';
+export { B as BackgroundSyncOptions, h as BackgroundSyncSystem, e as HealthCheckResult, H as HealthMonitorOptions, M as MetricsCollectorOptions, P as PowerSyncRawStatus, c as SyncControlActions, f as SyncEvent, g as SyncEventListener, d as SyncOperationData, S as SyncScope, a as SyncStatusState, b as SyncStatusTrackerOptions, U as Unsubscribe, i as defineBackgroundSyncTask, j as initializeBackgroundSync, k as isBackgroundSyncRegistered, r as registerBackgroundSync, u as unregisterBackgroundSync } from './background-sync-ChCXW-EV.js';
+export { DeadLetterEntry, DeadLetterQueue, DeadLetterQueueListener, DeadLetterQueueOptions, DeadLetterReason, HealthMonitor, MetricsCollector, SyncStatusTracker, createDeadLetterEntry, generateDLQEntryId } from './sync/index.js';
 import { SupabaseClient } from '@supabase/supabase-js';
-export { AttachmentQueueContext, CompletedTransactionsContext, CompletedTransactionsContextValue, ConnectionHealthContext, ConnectionHealthContextValue, ConnectionStatusContext, ConnectionStatusContextValue, DEFAULT_CONNECTION_HEALTH, DEFAULT_SYNC_CONFIG, DEFAULT_SYNC_METRICS, DEFAULT_SYNC_STATUS, EntitySyncStatusResult, FailedTransactionsContext, FailedTransactionsContextValue, PendingMutationsContext, PendingMutationsContextValue, PowerSyncConfig, PowerSyncContext, PowerSyncContextValue, PowerSyncProvider, PowerSyncProviderProps, SyncActivityContext, SyncActivityContextValue, SyncActivityResult, SyncConfig, SyncMetricsContext, SyncMetricsContextValue, SyncModeContext, SyncModeContextValue, SyncStatusContext, SyncStatusContextValue, UploadStatusResult, useAttachmentQueue, useCompletedTransactionsContext, useConnectionHealth, useConnectionStatus, useDatabase, useDownloadProgress, useEntitySyncStatus, useFailedTransactionsContext, useIsSyncing, useOnlineStatus, usePendingMutations, usePendingMutationsContext, usePlatform, usePowerSync, useSyncActivity, useSyncActivityContext, useSyncControl, useSyncMetrics, useSyncMode, useSyncModeContext, useSyncStatus, useUploadStatus } from './provider/index.js';
+export { DatabaseMaintenanceUtils, checkIntegrityImpl, checkStorageQuotaImpl, compactDatabaseImpl, getCacheStatsImpl, useDatabaseMaintenance } from './maintenance/index.js';
+export { D as DownloadResult, a as StorageBackend, b as StorageUploadOptions, d as SupabaseClient, S as SupabaseStorage, c as SupabaseStorageOptions, e as SupabaseTransformOptions, U as UploadProgress, r as resolveBucket } from './types-D0WcHrq6.js';
+export { f as CacheSettings, C as CacheSettingsManager, h as CacheSettingsManagerOptions, D as DEFAULT_CACHE_SETTINGS, I as ImageTransformOptions, S as SupabaseStorageAdapter, e as SupabaseStorageAdapterOptions, c as createSupabaseStorage, d as createSupabaseStorageAdapter, g as getStorageErrorMessage, a as isBlobResult, i as isFileResult, b as isStorageAuthError, n as normalizeStoragePath } from './CacheSettingsManager-uz-kbnRH.js';
+export { D as DEFAULT_UPLOAD_NOTIFICATION, S as SupabaseUploadHandlerOptions, U as UploadEventHandlers, a as UploadNotificationConfig } from './types-CyvBaAl8.js';
+export { SupabaseUploadHandler, createSupabaseUploadHandler } from './storage/upload/index.js';
+export { PowerSyncErrorBoundary } from './error/index.js';
+export { AttachmentQueueContext, BackgroundSyncCallbacks, BackgroundSyncConfig, BackgroundSyncStatus, CompletedTransactionsContext, CompletedTransactionsContextValue, ConnectionHealthContext, ConnectionHealthContextValue, ConnectionStatusContext, ConnectionStatusContextValue, DEFAULT_CONNECTION_HEALTH, DEFAULT_SYNC_CONFIG, DEFAULT_SYNC_METRICS, DEFAULT_SYNC_STATUS, DataLayerConfig, DataLayerIntegration, EntitySyncStatusResult, FailedTransactionsContext, FailedTransactionsContextValue, OfflineDataAttachmentConfig, OfflineDataProvider, OfflineDataProviderConfig, OfflineDataProviderProps, PendingMutationsContext, PendingMutationsContextValue, PowerSyncConfig, PowerSyncContext, PowerSyncContextValue, PowerSyncProvider, PowerSyncProviderProps, PowerSyncSyncStatusSnapshot, ProviderBridge, ProviderBridgeProps, SyncActivityContext, SyncActivityContextValue, SyncActivityResult, SyncConfig, SyncMetricsContext, SyncMetricsContextValue, SyncModeContext, SyncModeContextValue, SyncStatusContext, SyncStatusContextValue, UploadStatusResult, useAttachmentQueue, useAttachmentQueueReady, useCompletedTransactions, useCompletedTransactionsContext, useConnectionHealth, useConnectionStatus, useDatabase, useDownloadProgress, useEntitySyncStatus, useFailedTransactions, useFailedTransactionsContext, useIsSyncing, useOnlineStatus, usePendingMutations, usePendingMutationsContext, usePlatform, usePowerSync, useSyncActivity, useSyncActivityContext, useSyncControl, useSyncMetrics, useSyncMode, useSyncModeContext, useSyncStatus, useUploadStatus } from './provider/index.js';
+export { AttachmentQueueContextValue, SlimPowerSyncProvider, useAttachmentQueueContext, usePowerSyncContext, useSyncStatusContext } from './react/index.js';
 export { AsyncStorageAdapter, CompressedImage, CompressionOptions, ConnectionType, DatabaseOptions, FileInfo, FileSystemAdapter, ImageProcessorAdapter, LoggerAdapter, NetworkAdapter, PlatformAdapter, PlatformType, detectPlatform } from './platform/index.js';
-import '@tanstack/react-query';
+export { ATTACHMENT_TABLE, AbstractAttachmentQueue, AttachmentState, AttachmentTable, AttachmentTableOptions, AttachmentQueueOptions as BaseAttachmentQueueOptions, DEFAULT_ATTACHMENT_QUEUE_OPTIONS, EncodingType, AttachmentRecord as OfficialAttachmentRecord, StorageAdapter } from '@powersync/attachments';
+export { AbstractPowerSyncDatabase as PowerSyncDBInterface } from '@powersync/common';
 import 'react';
+import '@tanstack/react-query';
+import '@powersync/react-native';
 
 /**
  * Exponential backoff retry utilities for resilient network operations.
@@ -150,6 +162,74 @@ declare const DEFAULT_BACKOFF_CONFIG: BackoffConfig;
  */
 declare function withExponentialBackoff<T>(fn: () => Promise<T>, config: BackoffConfig, options?: BackoffOptions): Promise<T>;
 
+/**
+ * Format bytes to human-readable string
+ *
+ * @param bytes - Number of bytes to format
+ * @param decimals - Number of decimal places (default: 2)
+ * @returns Formatted string like "1.5 MB", "256 KB", etc.
+ */
+declare function formatBytes(bytes: number, decimals?: number): string;
+
+/**
+ * MIME Type Utilities for @pol-studios/powersync
+ *
+ * Provides file extension to MIME type mapping for storage operations.
+ */
+/**
+ * Get MIME type from file extension.
+ *
+ * @param extension - File extension (with or without leading dot)
+ * @returns MIME type string
+ *
+ * @example
+ * ```typescript
+ * getMimeType('jpg');     // 'image/jpeg'
+ * getMimeType('.png');    // 'image/png'
+ * getMimeType('unknown'); // 'application/octet-stream'
+ * getMimeType(undefined); // 'application/octet-stream'
+ * ```
+ */
+declare function getMimeType(extension: string | undefined | null): string;
+/**
+ * Get MIME type from a file path or filename.
+ *
+ * @param filePath - Full file path or filename
+ * @returns MIME type string
+ *
+ * @example
+ * ```typescript
+ * getMimeTypeFromPath('/path/to/image.jpg');     // 'image/jpeg'
+ * getMimeTypeFromPath('document.pdf');           // 'application/pdf'
+ * getMimeTypeFromPath('file-without-extension'); // 'application/octet-stream'
+ * ```
+ */
+declare function getMimeTypeFromPath(filePath: string | undefined | null): string;
+/**
+ * Check if a MIME type represents an image.
+ */
+declare function isImageMimeType(mimeType: string): boolean;
+/**
+ * Check if a MIME type represents a video.
+ */
+declare function isVideoMimeType(mimeType: string): boolean;
+/**
+ * Check if a MIME type represents audio.
+ */
+declare function isAudioMimeType(mimeType: string): boolean;
+/**
+ * Check if a MIME type represents a document (PDF, Office, etc.).
+ */
+declare function isDocumentMimeType(mimeType: string): boolean;
+/**
+ * Get file extension from MIME type (reverse lookup).
+ * Returns the most common extension for the given MIME type.
+ *
+ * @param mimeType - MIME type string
+ * @returns File extension without leading dot, or undefined if unknown
+ */
+declare function getExtensionFromMimeType(mimeType: string): string | undefined;
+
 /**
  * Conflict Detection for @pol-studios/powersync
  *
@@ -157,6 +237,16 @@ declare function withExponentialBackoff<T>(fn: () => Promise<T>, config: Backoff
  * Only queries AuditLog when version mismatch is detected.
  */
 
+/**
+ * Error thrown when conflict detection fails due to external issues
+ * (e.g., AuditLog query failure). Callers should handle this and decide
+ * whether to retry, fail the sync, or escalate to the user.
+ */
+declare class ConflictDetectionError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
 /**
  * Detect conflicts between local pending changes and server state.
  *
@@ -202,4 +292,4 @@ declare function fetchServerVersion(table: string, recordId: string, schema: str
  */
 declare function getLocalVersion(table: string, recordId: string, db: AbstractPowerSyncDatabase): Promise<number | null>;
 
-export { AbortError, AbstractPowerSyncDatabase, type BackoffConfig, type BackoffOptions, ConflictCheckResult, ConflictDetectionConfig, DEFAULT_BACKOFF_CONFIG, RetryExhaustedError, addJitter, calculateBackoffDelay, detectConflicts, fetchServerVersion, getLocalVersion, hasVersionColumn, sleep, withExponentialBackoff };
+export { AbortError, AbstractPowerSyncDatabase, type BackoffConfig, type BackoffOptions, ConflictCheckResult, ConflictDetectionConfig, ConflictDetectionError, DEFAULT_BACKOFF_CONFIG, RetryExhaustedError, addJitter, calculateBackoffDelay, detectConflicts, fetchServerVersion, formatBytes, getExtensionFromMimeType, getLocalVersion, getMimeType, getMimeTypeFromPath, hasVersionColumn, isAudioMimeType, isDocumentMimeType, isImageMimeType, isVideoMimeType, sleep, withExponentialBackoff };