@pol-studios/powersync 1.0.6 → 1.0.7

package/dist/chunk-BREGB4WL.js

@@ -0,0 +1,1768 @@
+import {
+  PowerSyncErrorBoundary
+} from "./chunk-P6WOZO7H.js";
+import {
+  createPolAttachmentQueue
+} from "./chunk-ZEOKPWUC.js";
+import {
+  DEFAULT_CONNECTION_HEALTH,
+  DEFAULT_SYNC_METRICS,
+  DEFAULT_SYNC_STATUS,
+  HealthMonitor,
+  MetricsCollector,
+  SyncStatusTracker
+} from "./chunk-H772V6XQ.js";
+import {
+  AttachmentQueueContext,
+  CompletedTransactionsContext,
+  ConnectionHealthContext,
+  ConnectionStatusContext,
+  FailedTransactionsContext,
+  PendingMutationsContext,
+  PowerSyncContext,
+  SyncActivityContext,
+  SyncMetricsContext,
+  SyncModeContext,
+  SyncStatusContext,
+  useOnlineStatus,
+  usePendingMutationsContext,
+  usePowerSync,
+  useSyncStatus
+} from "./chunk-YSTEESEG.js";
+import {
+  SupabaseStorageAdapter
+} from "./chunk-WQ5MPAVC.js";
+import {
+  createNativePlatformAdapter
+} from "./chunk-53WH2JJV.js";
+import {
+  SupabaseConnector
+} from "./chunk-HFOFLW5F.js";
+import {
+  createSyncError,
+  extractEntityIds,
+  extractTableNames
+} from "./chunk-XQAJM2MW.js";
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
+
+// src/provider/PowerSyncProvider.tsx
+import { useEffect, useState, useRef, useMemo, useCallback } from "react";
+
+// src/conflicts/conflict-bus.ts
+var ConflictBus = class _ConflictBus {
+  static MAX_PENDING = 100;
+  conflictListeners = /* @__PURE__ */ new Set();
+  resolutionListeners = /* @__PURE__ */ new Set();
+  pendingConflicts = [];
+  /**
+   * Subscribe to conflict detection events.
+   * Flushes any pending conflicts to ALL listeners (including the new one).
+   * @returns Unsubscribe function
+   */
+  onConflict(listener) {
+    this.conflictListeners.add(listener);
+    if (this.pendingConflicts.length > 0) {
+      const pending = [...this.pendingConflicts];
+      this.pendingConflicts = [];
+      for (const conflict of pending) {
+        this.conflictListeners.forEach((l) => l(conflict));
+      }
+    }
+    return () => this.conflictListeners.delete(listener);
+  }
+  /**
+   * Subscribe to resolution events.
+   * @returns Unsubscribe function
+   */
+  onResolution(listener) {
+    this.resolutionListeners.add(listener);
+    return () => this.resolutionListeners.delete(listener);
+  }
+  /**
+   * Emit a conflict detection event (called by connector).
+   * If no listeners are subscribed, queues the conflict for later delivery.
+   */
+  emitConflict(conflict) {
+    if (this.conflictListeners.size === 0) {
+      console.warn("[ConflictBus] No listeners - queueing conflict");
+      if (this.pendingConflicts.length >= _ConflictBus.MAX_PENDING) {
+        console.warn("[ConflictBus] Pending queue full, dropping oldest conflict");
+        this.pendingConflicts.shift();
+      }
+      this.pendingConflicts.push(conflict);
+      return;
+    }
+    this.conflictListeners.forEach((listener) => listener(conflict));
+  }
+  /**
+   * Emit a resolution event (called by UI/ConflictContext).
+   */
+  emitResolution(table, recordId, resolution) {
+    this.resolutionListeners.forEach((listener) => listener(table, recordId, resolution));
+  }
+  /**
+   * Clear all listeners and pending conflicts (for cleanup).
+   */
+  destroy() {
+    this.conflictListeners.clear();
+    this.resolutionListeners.clear();
+    this.pendingConflicts = [];
+  }
+  /**
+   * Get the number of pending conflicts (useful for debugging/testing).
+   */
+  get pendingCount() {
+    return this.pendingConflicts.length;
+  }
+};
+
+// src/provider/PowerSyncProvider.tsx
+import { jsx } from "react/jsx-runtime";
+function PowerSyncProvider({
+  config,
+  children,
+  onReady,
+  onError,
+  onSyncStatusChange
+}) {
+  const {
+    platform,
+    schema,
+    powerSyncUrl,
+    supabaseClient,
+    dbFilename = "powersync.db",
+    connector: connectorConfig,
+    attachments: attachmentConfig,
+    sync: syncConfig
+  } = config;
+  const logger = platform.logger;
+  const mergedSyncConfig = {
+    autoConnect: syncConfig?.autoConnect ?? true,
+    syncInterval: syncConfig?.syncInterval ?? 0,
+    enableHealthMonitoring: syncConfig?.enableHealthMonitoring ?? true,
+    enableMetrics: syncConfig?.enableMetrics ?? true
+  };
+  const [db, setDb] = useState(null);
+  const [connector, setConnector] = useState(null);
+  const [attachmentQueue, setAttachmentQueue] = useState(null);
+  const [isReady, setIsReady] = useState(false);
+  const [isInitializing, setIsInitializing] = useState(true);
+  const [attachmentQueueReady, setAttachmentQueueReady] = useState(!attachmentConfig);
+  const [error, setError] = useState(null);
+  const [session, setSession] = useState(null);
+  const conflictBusRef = useRef(null);
+  if (!conflictBusRef.current) {
+    conflictBusRef.current = new ConflictBus();
+  }
+  const conflictBus = conflictBusRef.current;
+  const [syncStatus, setSyncStatus] = useState(DEFAULT_SYNC_STATUS);
+  const [pendingMutations, setPendingMutations] = useState([]);
+  const [syncModeState, setSyncModeState] = useState({
+    loaded: false,
+    mode: "push-pull"
+  });
+  const [lastSyncedAt, setLastSyncedAt] = useState(null);
+  const [connectionError, setConnectionError] = useState(null);
+  const [failedTransactions, setFailedTransactions] = useState([]);
+  const [completedTransactions, setCompletedTransactions] = useState([]);
+  const [newCompletedTransactions, setNewCompletedTransactions] = useState([]);
+  const [connectionHealth, setConnectionHealth] = useState(DEFAULT_CONNECTION_HEALTH);
+  const [syncMetrics, setSyncMetrics] = useState(DEFAULT_SYNC_METRICS);
+  const [isAutoOffline, setIsAutoOffline] = useState(false);
+  const [networkReachable, setNetworkReachable] = useState(true);
+  const statusTrackerRef = useRef(null);
+  const metricsCollectorRef = useRef(null);
+  const healthMonitorRef = useRef(null);
+  const attachmentQueueRef = useRef(null);
+  const listenerUnsubscribeRef = useRef(null);
+  const wasSyncingRef = useRef(false);
+  const wasUploadingRef = useRef(false);
+  const initializingRef = useRef(false);
+  const dbClosedRef = useRef(false);
+  const connectorRef = useRef(null);
+  const cleanupPromiseRef = useRef(null);
+  const isCleaningUpRef = useRef(false);
+  const prevNetworkConnectedRef = useRef(null);
+  const autoOfflineInitializedRef = useRef(false);
+  const isAutoOfflineRef = useRef(false);
+  const syncModeRef = useRef("push-pull");
+  const removePendingMutationRef = useRef(() => {
+  });
+  const onSyncStatusChangeRef = useRef(onSyncStatusChange);
+  const onReadyRef = useRef(onReady);
+  const onErrorRef = useRef(onError);
+  useEffect(() => {
+    onSyncStatusChangeRef.current = onSyncStatusChange;
+  }, [onSyncStatusChange]);
+  useEffect(() => {
+    onReadyRef.current = onReady;
+  }, [onReady]);
+  useEffect(() => {
+    onErrorRef.current = onError;
+  }, [onError]);
+  useEffect(() => {
+    isAutoOfflineRef.current = isAutoOffline;
+    syncModeRef.current = syncModeState.mode;
+  }, [isAutoOffline, syncModeState.mode]);
+  useEffect(() => {
+    const statusTracker = new SyncStatusTracker(platform.storage, logger, {
+      onStatusChange: (status) => {
+        setSyncStatus(status);
+        setLastSyncedAt(status.lastSyncedAt);
+        onSyncStatusChangeRef.current?.(status);
+      }
+    });
+    statusTrackerRef.current = statusTracker;
+    const metricsCollector = new MetricsCollector(platform.storage, logger, {
+      onMetricsChange: setSyncMetrics
+    });
+    metricsCollectorRef.current = metricsCollector;
+    const healthMonitor = new HealthMonitor(logger, {
+      onHealthChange: setConnectionHealth
+    });
+    healthMonitorRef.current = healthMonitor;
+    const initPromise = Promise.all([statusTracker.init(), metricsCollector.init()]);
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        logger.warn("[PowerSyncProvider] Sync mode state load timed out, using default (push-pull)");
+        resolve([void 0, void 0]);
+      }, 5e3);
+    });
+    Promise.race([initPromise, timeoutPromise]).then(() => {
+      const loadedMode = statusTracker.getSyncMode();
+      const loadedIsAutoOffline = statusTracker.getIsAutoOffline();
+      logger.info("[PowerSyncProvider] Sync mode state loaded:", {
+        mode: loadedMode,
+        isAutoOffline: loadedIsAutoOffline
+      });
+      setSyncModeState({
+        loaded: true,
+        mode: loadedMode
+      });
+      setIsAutoOffline(loadedIsAutoOffline);
+      setCompletedTransactions(statusTracker.getCompletedTransactions());
+      setNewCompletedTransactions(statusTracker.getNewCompletedTransactions());
+      setFailedTransactions(statusTracker.getFailedTransactions());
+    });
+    return () => {
+      statusTracker.dispose();
+      metricsCollector.dispose();
+      healthMonitor.dispose();
+    };
+  }, [platform, logger]);
+  useEffect(() => {
+    logger.debug("[PowerSyncProvider] Setting up auth listener");
+    supabaseClient.auth.getSession().then(({
+      data: {
+        session: initialSession
+      }
+    }) => {
+      logger.debug("[PowerSyncProvider] Initial session:", !!initialSession);
+      setSession(initialSession);
+    });
+    const {
+      data: {
+        subscription
+      }
+    } = supabaseClient.auth.onAuthStateChange((_event, newSession) => {
+      logger.debug("[PowerSyncProvider] Auth state changed, hasSession:", !!newSession);
+      setSession(newSession);
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [supabaseClient, logger]);
+  useEffect(() => {
+    if (initializingRef.current) {
+      logger.debug("[PowerSyncProvider] Already initializing, skipping...");
+      return;
+    }
+    initializingRef.current = true;
+    const controller = {
+      cancelled: false
+    };
+    const initDatabase = async () => {
+      try {
+        if (cleanupPromiseRef.current) {
+          logger.debug("[PowerSyncProvider] Waiting for cleanup to complete...");
+          await cleanupPromiseRef.current;
+          if (controller.cancelled) {
+            initializingRef.current = false;
+            return;
+          }
+          logger.debug("[PowerSyncProvider] Cleanup complete, proceeding with init");
+        }
+        dbClosedRef.current = false;
+        logger.info("[PowerSyncProvider] Initializing database...");
+        const database = await platform.createDatabase({
+          dbFilename,
+          schema
+        });
+        if (controller.cancelled) {
+          logger.debug("[PowerSyncProvider] Init cancelled, closing database...");
+          await database.close();
+          initializingRef.current = false;
+          return;
+        }
+        logger.info("[PowerSyncProvider] Database initialized");
+        setDb(database);
+        setIsReady(true);
+        setIsInitializing(false);
+        healthMonitorRef.current?.setDatabase(database);
+        if (mergedSyncConfig.enableHealthMonitoring) {
+          healthMonitorRef.current?.start();
+        }
+        onReadyRef.current?.();
+      } catch (err) {
+        const initError = err instanceof Error ? err : new Error(String(err));
+        logger.error("[PowerSyncProvider] Initialization failed:", initError);
+        if (!controller.cancelled) {
+          setError(initError);
+          setIsInitializing(false);
+          onErrorRef.current?.(initError);
+        }
+        initializingRef.current = false;
+      }
+    };
+    initDatabase();
+    return () => {
+      controller.cancelled = true;
+      initializingRef.current = false;
+    };
+  }, [platform, dbFilename, schema, logger, mergedSyncConfig.enableHealthMonitoring]);
+  useEffect(() => {
+    if (__DEV__) {
+      console.log("[PowerSyncProvider] Connect effect triggered:", {
+        hasDb: !!db,
+        hasSession: !!session,
+        autoConnect: mergedSyncConfig.autoConnect,
+        syncModeState
+      });
+    }
+    logger.info("[PowerSyncProvider] Connect effect - db:", !!db, "session:", !!session, "autoConnect:", mergedSyncConfig.autoConnect, "syncModeLoaded:", syncModeState.loaded, "syncMode:", syncModeState.mode);
+    if (!db) {
+      logger.debug("[PowerSyncProvider] Connect effect - waiting for db");
+      return;
+    }
+    if (!session) {
+      logger.debug("[PowerSyncProvider] Connect effect - no session");
+      return;
+    }
+    if (!mergedSyncConfig.autoConnect) {
+      logger.debug("[PowerSyncProvider] Connect effect - autoConnect disabled");
+      return;
+    }
+    if (!syncModeState.loaded) {
+      logger.info("[PowerSyncProvider] Waiting for sync mode state to load...");
+      return;
+    }
+    if (syncModeState.mode === "offline") {
+      logger.debug("[PowerSyncProvider] Skipping connect - offline mode");
+      return;
+    }
+    const abortController = new AbortController();
+    const connectPowerSync = async () => {
+      try {
+        if (abortController.signal.aborted) {
+          logger.debug("[PowerSyncProvider] Connect aborted before start");
+          return;
+        }
+        setConnectionError(null);
+        if (connectorRef.current) {
+          connectorRef.current.destroy();
+          connectorRef.current = null;
+        }
+        if (abortController.signal.aborted) {
+          logger.debug("[PowerSyncProvider] Connect aborted after connector cleanup");
+          return;
+        }
+        const statusTracker_0 = statusTrackerRef.current;
+        const newConnector = new SupabaseConnector({
+          supabaseClient,
+          powerSyncUrl,
+          schemaRouter: connectorConfig?.schemaRouter,
+          crudHandler: connectorConfig?.crudHandler,
+          retryConfig: connectorConfig?.retryConfig,
+          logger,
+          // Conflict detection - enabled by default
+          conflictDetection: {
+            enabled: true
+          },
+          conflictBus,
+          // Check if uploads should be performed based on sync mode
+          shouldUpload: () => statusTrackerRef.current?.shouldUpload() ?? true,
+          // Clear failures when transaction succeeds
+          onTransactionSuccess: (entries) => {
+            if (!statusTracker_0) return;
+            const entityIds = extractEntityIds(entries);
+            entityIds.forEach((id) => {
+              const failures = statusTracker_0.getFailuresForEntity(id);
+              failures.forEach((f) => statusTracker_0.clearFailure(f.id));
+            });
+            setFailedTransactions(statusTracker_0.getFailedTransactions());
+          },
+          // Record failures when transaction fails
+          onTransactionFailure: (entries_0, error_0, classified) => {
+            if (!statusTracker_0) return;
+            statusTracker_0.recordTransactionFailure(entries_0, createSyncError(classified, error_0.message), classified.isPermanent, extractEntityIds(entries_0), extractTableNames(entries_0));
+            setFailedTransactions(statusTracker_0.getFailedTransactions());
+          },
+          // Record completed transactions
+          onTransactionComplete: (entries_1) => {
+            if (!statusTracker_0) return;
+            statusTracker_0.recordTransactionComplete(entries_1);
+            setCompletedTransactions(statusTracker_0.getCompletedTransactions());
+            setNewCompletedTransactions(statusTracker_0.getNewCompletedTransactions());
+          }
+        });
+        if (abortController.signal.aborted) {
+          logger.debug("[PowerSyncProvider] Connect aborted after connector creation, destroying new connector");
+          newConnector.destroy();
+          return;
+        }
+        setConnector(newConnector);
+        connectorRef.current = newConnector;
+        if (db.connected) {
+          logger.debug("[PowerSyncProvider] Already connected, reconnecting...");
+          await db.disconnect();
+        }
+        if (abortController.signal.aborted) {
+          logger.debug("[PowerSyncProvider] Connect aborted after disconnect");
+          return;
+        }
+        logger.info("[PowerSyncProvider] Connecting to PowerSync...");
+        await db.connect(newConnector);
+        if (abortController.signal.aborted) {
+          logger.debug("[PowerSyncProvider] Connect aborted after connection established");
+          return;
+        }
+        if (db.connected) {
+          logger.info("[PowerSyncProvider] Connected successfully");
+          healthMonitorRef.current?.resetReconnectAttempts();
+        } else {
+          logger.warn("[PowerSyncProvider] Connection initiated but streaming not established - check PowerSync URL");
+        }
+      } catch (err_0) {
+        if (abortController.signal.aborted) {
+          logger.debug("[PowerSyncProvider] Connect error ignored due to abort");
+          return;
+        }
+        const connectError = err_0 instanceof Error ? err_0 : new Error(String(err_0));
+        logger.error("[PowerSyncProvider] Connection failed:", connectError);
+        setConnectionError(connectError);
+        healthMonitorRef.current?.recordReconnectAttempt();
+      }
+    };
+    connectPowerSync();
+    return () => {
+      abortController.abort();
+    };
+  }, [db, session, powerSyncUrl, supabaseClient, connectorConfig, conflictBus, mergedSyncConfig.autoConnect, syncModeState, logger]);
+  useEffect(() => {
+    if (!db) return;
+    const initialStatus = db.currentStatus;
+    if (initialStatus) {
+      statusTrackerRef.current?.handleStatusChange(initialStatus);
+    }
+    const unsubscribe = db.registerListener({
+      statusChanged: (status_0) => {
+        statusTrackerRef.current?.handleStatusChange(status_0);
+        const dataFlow = status_0.dataFlowStatus;
+        const isDownloading = dataFlow?.downloading ?? false;
+        const isUploading = dataFlow?.uploading ?? false;
+        const progress = status_0.downloadProgress;
+        if (isDownloading && !wasSyncingRef.current) {
+          logger.info("[PowerSyncProvider] Downloading from server...");
+          metricsCollectorRef.current?.markSyncStart();
+        }
+        if (!isDownloading && wasSyncingRef.current) {
+          const duration = metricsCollectorRef.current?.markSyncEnd();
+          logger.info("[PowerSyncProvider] Download complete", duration ? `(${duration}ms)` : "");
+          if (duration !== null && duration !== void 0) {
+            metricsCollectorRef.current?.recordSync({
+              durationMs: duration,
+              success: true,
+              operationsDownloaded: progress?.totalOperations ?? 0
+            });
+          }
+        }
+        if (isUploading && !wasUploadingRef.current) {
+          logger.info("[PowerSyncProvider] Uploading local changes...");
+        }
+        if (!isUploading && wasUploadingRef.current) {
+          logger.info("[PowerSyncProvider] Upload complete");
+        }
+        wasSyncingRef.current = isDownloading;
+        wasUploadingRef.current = isUploading;
+      }
+    });
+    listenerUnsubscribeRef.current = unsubscribe;
+    return () => {
+      unsubscribe();
+      listenerUnsubscribeRef.current = null;
+    };
+  }, [db]);
+  const hydratePendingMutations = useCallback(async () => {
+    if (!db || dbClosedRef.current) {
+      return;
+    }
+    try {
+      const rows = await db.getAll("SELECT id, tx_id, data FROM ps_crud ORDER BY id ASC");
+      const mutations = rows.map((row) => {
+        try {
+          const parsed = JSON.parse(row.data);
+          let createdAt = /* @__PURE__ */ new Date();
+          if (parsed.data?._metadata) {
+            try {
+              const metadata = typeof parsed.data._metadata === "string" ? JSON.parse(parsed.data._metadata) : parsed.data._metadata;
+              if (metadata?.createdAt) {
+                createdAt = new Date(metadata.createdAt);
+              }
+            } catch {
+            }
+          }
+          return {
+            id: parsed.data?.id ?? parsed.id ?? row.id,
+            clientId: parseInt(row.id, 10) || 0,
+            op: parsed.op ?? "PUT",
+            table: parsed.type ?? "unknown",
+            opData: parsed.data,
+            transactionId: row.tx_id ?? void 0,
+            createdAt
+          };
+        } catch {
+          return null;
+        }
+      }).filter((e) => e !== null);
+      if (!dbClosedRef.current) {
+        statusTrackerRef.current?.updatePendingMutations(mutations);
+        setPendingMutations(mutations);
+      }
+    } catch {
+    }
+  }, [db]);
+  const addPendingMutation = useCallback((entry) => {
+    const entryWithTimestamp = {
+      ...entry,
+      createdAt: entry.createdAt ?? /* @__PURE__ */ new Date()
+    };
+    setPendingMutations((prev) => {
+      const newMutations = [...prev, entryWithTimestamp];
+      statusTrackerRef.current?.updatePendingMutations(newMutations);
+      return newMutations;
+    });
+  }, []);
+  const removePendingMutation = useCallback((id_0) => {
+    setPendingMutations((prev_0) => {
+      const newMutations_0 = prev_0.filter((m) => m.id !== id_0);
+      statusTrackerRef.current?.updatePendingMutations(newMutations_0);
+      return newMutations_0;
+    });
+  }, []);
+  useEffect(() => {
+    removePendingMutationRef.current = removePendingMutation;
+  }, [removePendingMutation]);
+  useEffect(() => {
+    if (!db) return;
+    dbClosedRef.current = false;
+    hydratePendingMutations();
+  }, [db, hydratePendingMutations]);
+  useEffect(() => {
+    if (!db || !attachmentConfig || attachmentQueueRef.current) {
+      return;
+    }
+    const controller_0 = {
+      cancelled: false
+    };
+    const initAttachmentQueue = async () => {
+      try {
+        logger.info("[PowerSyncProvider] Initializing attachment queue...");
+        const queue = createPolAttachmentQueue(
+          db,
+          // PowerSync DB instance
+          platform,
+          attachmentConfig
+        );
+        await queue.init();
+        if (controller_0.cancelled) {
+          queue.dispose();
+          return;
+        }
+        attachmentQueueRef.current = queue;
+        setAttachmentQueue(queue);
+        setAttachmentQueueReady(true);
+        logger.info("[PowerSyncProvider] Attachment queue initialized successfully");
+      } catch (err_1) {
+        if (!controller_0.cancelled) {
+          logger.error("[PowerSyncProvider] Attachment queue initialization failed:", err_1);
+          setAttachmentQueueReady(true);
+        }
+      }
+    };
+    initAttachmentQueue();
+    return () => {
+      controller_0.cancelled = true;
+      attachmentQueueRef.current?.dispose();
+      attachmentQueueRef.current = null;
+      setAttachmentQueueReady(false);
+    };
+  }, [db, attachmentConfig, platform, logger]);
+  useEffect(() => {
+    return () => {
+      if (isCleaningUpRef.current) {
+        logger.debug("[PowerSyncProvider] Cleanup already in progress, skipping...");
+        return;
+      }
+      logger.info("[PowerSyncProvider] Cleaning up...");
+      isCleaningUpRef.current = true;
+      dbClosedRef.current = true;
+      connectorRef.current?.destroy();
+      connectorRef.current = null;
+      listenerUnsubscribeRef.current?.();
+      attachmentQueueRef.current?.dispose();
+      healthMonitorRef.current?.stop();
+      conflictBusRef.current?.destroy();
+      if (db) {
+        cleanupPromiseRef.current = (async () => {
+          try {
+            await db.disconnect();
+            await db.close();
+            logger.debug("[PowerSyncProvider] Database cleanup completed");
+          } catch (err_2) {
+            const errorMessage = err_2 instanceof Error ? err_2.message : String(err_2);
+            if (!errorMessage.includes("not open") && !errorMessage.includes("closed")) {
+              logger.warn("[PowerSyncProvider] Error during cleanup:", err_2);
+            }
+          } finally {
+            isCleaningUpRef.current = false;
+            cleanupPromiseRef.current = null;
+          }
+        })();
+      } else {
+        isCleaningUpRef.current = false;
+      }
+    };
+  }, [db, logger]);
+  useEffect(() => {
+    if (!isReady || !syncModeState.loaded) return;
+    const handleNetworkChange = async (isConnected) => {
+      const wasConnected = prevNetworkConnectedRef.current;
+      prevNetworkConnectedRef.current = isConnected;
+      const tracker = statusTrackerRef.current;
+      if (tracker) {
+        tracker.setNetworkReachable(isConnected);
+      }
+      setNetworkReachable(isConnected);
+      if (!autoOfflineInitializedRef.current) {
+        autoOfflineInitializedRef.current = true;
+        logger.debug("[PowerSyncProvider] Auto-offline initialized, network:", isConnected);
+        return;
+      }
+      if (wasConnected === true && !isConnected) {
+        logger.info("[PowerSyncProvider] Network lost - auto-entering offline mode");
+        const tracker_0 = statusTrackerRef.current;
+        if (tracker_0) {
+          await tracker_0.setIsAutoOffline(true);
+          setIsAutoOffline(true);
+          await tracker_0.setSyncMode("offline");
+          setSyncModeState({
+            loaded: true,
+            mode: "offline"
+          });
+        }
+        return;
+      }
+      if (wasConnected === false && isConnected) {
+        if (isAutoOfflineRef.current && syncModeRef.current === "offline") {
+          logger.info("[PowerSyncProvider] Network restored - auto-resuming sync");
+          const tracker_1 = statusTrackerRef.current;
+          if (tracker_1) {
+            await tracker_1.setIsAutoOffline(false);
+            setIsAutoOffline(false);
+            await tracker_1.setSyncMode("push-pull");
+            setSyncModeState({
+              loaded: true,
+              mode: "push-pull"
+            });
+            if (db && connector && !db.connected) {
+              try {
+                await db.connect(connector);
+                logger.info("[PowerSyncProvider] Reconnected after network restore");
+              } catch (err_3) {
+                logger.warn("[PowerSyncProvider] Failed to reconnect after network restore:", err_3);
+              }
+            }
+          }
+        } else {
+          logger.debug("[PowerSyncProvider] Network restored but not auto-resuming (manual offline or different mode)");
+        }
+      }
+    };
+    const unsubscribe_0 = platform.network.addConnectionListener(handleNetworkChange);
+    platform.network.isConnected().then((connected) => {
+      prevNetworkConnectedRef.current = connected;
+      autoOfflineInitializedRef.current = true;
+      const tracker_2 = statusTrackerRef.current;
+      if (tracker_2) {
+        tracker_2.setNetworkReachable(connected);
+      }
+      setNetworkReachable(connected);
+      if (connected && isAutoOfflineRef.current && syncModeRef.current === "offline") {
+        logger.info("[PowerSyncProvider] Network available on startup with auto-offline active, auto-resuming from offline");
+        if (tracker_2) {
+          tracker_2.setIsAutoOffline(false);
+          setIsAutoOffline(false);
+          tracker_2.setSyncMode("push-pull");
+          setSyncModeState({
+            loaded: true,
+            mode: "push-pull"
+          });
+          if (db && connector && !db.connected) {
+            db.connect(connector).then(() => {
+              logger.info("[PowerSyncProvider] Reconnected after auto-resume on startup");
+            }).catch((err_4) => {
+              logger.warn("[PowerSyncProvider] Failed to reconnect after auto-resume on startup:", err_4);
+            });
+          }
+        }
+      }
+      logger.debug("[PowerSyncProvider] Auto-offline ready, initial network:", connected);
+    });
+    return () => {
+      unsubscribe_0();
+    };
+  }, [isReady, syncModeState.loaded, syncModeState.mode, isAutoOffline, db, connector, platform, logger]);
+  const clearFailure = useCallback((failureId) => {
+    const tracker_3 = statusTrackerRef.current;
+    if (!tracker_3) {
+      logger.warn("[PowerSyncProvider] Cannot clear failure - tracker not initialized");
+      return;
+    }
+    tracker_3.clearFailure(failureId);
+    setFailedTransactions(tracker_3.getFailedTransactions());
+  }, [logger]);
+  const clearAllFailures = useCallback(() => {
+    const tracker_4 = statusTrackerRef.current;
+    if (!tracker_4) {
+      logger.warn("[PowerSyncProvider] Cannot clear failures - tracker not initialized");
+      return;
+    }
+    tracker_4.clearAllFailures();
+    setFailedTransactions(tracker_4.getFailedTransactions());
+  }, [logger]);
+  const clearCompletedHistory = useCallback(() => {
+    const tracker_5 = statusTrackerRef.current;
+    if (!tracker_5) {
+      logger.warn("[PowerSyncProvider] Cannot clear completed history - tracker not initialized");
+      return;
+    }
+    tracker_5.clearCompletedHistory();
+    setCompletedTransactions(tracker_5.getCompletedTransactions());
+    setNewCompletedTransactions(tracker_5.getNewCompletedTransactions());
+  }, [logger]);
+  const clearCompletedItem = useCallback((completedId) => {
+    const tracker_6 = statusTrackerRef.current;
+    if (!tracker_6) {
+      logger.warn("[PowerSyncProvider] Cannot clear completed item - tracker not initialized");
+      return;
+    }
+    tracker_6.clearCompletedItem(completedId);
+    setCompletedTransactions(tracker_6.getCompletedTransactions());
+    setNewCompletedTransactions(tracker_6.getNewCompletedTransactions());
+  }, [logger]);
+  const markNotificationsAsSeen = useCallback(() => {
+    const tracker_7 = statusTrackerRef.current;
+    if (!tracker_7) {
+      logger.warn("[PowerSyncProvider] Cannot mark notifications as seen - tracker not initialized");
+      return;
+    }
+    tracker_7.markNotificationsAsSeen();
+    setNewCompletedTransactions(tracker_7.getNewCompletedTransactions());
+  }, [logger]);
+  const setSyncMode = useCallback(async (mode) => {
+    const tracker_8 = statusTrackerRef.current;
+    if (!tracker_8) {
+      logger.warn("[PowerSyncProvider] Cannot set sync mode - tracker not initialized");
+      return;
+    }
+    await tracker_8.setIsAutoOffline(false);
+    setIsAutoOffline(false);
+    await tracker_8.setSyncMode(mode);
+    setSyncModeState({
+      loaded: true,
+      mode
+    });
+  }, [logger]);
+  const setForceNextUpload = useCallback((force) => {
+    const tracker_9 = statusTrackerRef.current;
+    if (!tracker_9) {
+      logger.warn("[PowerSyncProvider] Cannot set force upload - tracker not initialized");
+      return;
+    }
+    tracker_9.setForceNextUpload(force);
+  }, [logger]);
+  const setAutoOfflineMode = useCallback(async (mode_0, isAuto) => {
+    const tracker_10 = statusTrackerRef.current;
+    if (!tracker_10) {
+      logger.warn("[PowerSyncProvider] Cannot set sync mode - tracker not initialized");
+      return;
+    }
+    await tracker_10.setIsAutoOffline(isAuto);
+    setIsAutoOffline(isAuto);
+    await tracker_10.setSyncMode(mode_0);
+    setSyncModeState({
+      loaded: true,
+      mode: mode_0
+    });
+  }, [logger]);
+  const discardPendingMutation = useCallback(async (clientId) => {
+    if (!db || !connector) {
+      logger.warn("[PowerSync] Cannot discard - not initialized");
+      return;
+    }
+    if (syncStatus.uploading) {
+      throw new Error("Cannot discard while upload is in progress");
+    }
+    logger.info("[PowerSync] Discarding pending mutation:", clientId);
+    await db.disconnect();
+    try {
+      await db.execute("DELETE FROM ps_crud WHERE id = ?", [clientId]);
+      logger.info("[PowerSync] Mutation discarded successfully");
+    } finally {
+      const currentConnector = connectorRef.current;
+      if (currentConnector && db) {
+        try {
+          await db.connect(currentConnector);
+        } catch (reconnectError) {
+          logger.error("[PowerSync] Failed to reconnect after discard:", reconnectError);
+          throw reconnectError;
+        }
+      }
+    }
+  }, [db, connector, syncStatus.uploading, logger]);
+  const discardAllPendingMutations = useCallback(async () => {
+    if (!db || !connector) {
+      logger.warn("[PowerSync] Cannot discard all - not initialized");
+      return;
+    }
+    if (syncStatus.uploading) {
+      throw new Error("Cannot discard while upload is in progress");
+    }
+    logger.info("[PowerSync] Discarding all pending mutations");
+    await db.disconnect();
+    try {
+      await db.execute("DELETE FROM ps_crud");
+      logger.info("[PowerSync] All mutations discarded successfully");
+    } finally {
+      const currentConnector = connectorRef.current;
+      if (currentConnector && db) {
+        try {
+          await db.connect(currentConnector);
+        } catch (reconnectError) {
+          logger.error("[PowerSync] Failed to reconnect after discard:", reconnectError);
+          throw reconnectError;
+        }
+      }
+    }
+  }, [db, connector, syncStatus.uploading, logger]);
+  const pauseAutoRetry = useCallback(() => {
+    if (!connector) {
+      logger.warn("[PowerSyncProvider] Cannot pause auto-retry - connector not initialized");
+      return;
+    }
+    connector.pauseAutoRetry();
+  }, [connector, logger]);
+  const resumeAutoRetry = useCallback(() => {
+    if (!connector) {
+      logger.warn("[PowerSyncProvider] Cannot resume auto-retry - connector not initialized");
+      return;
+    }
+    connector.resumeAutoRetry();
+  }, [connector, logger]);
+  const retryFailure = useCallback(async (failureId_0) => {
+    const tracker_11 = statusTrackerRef.current;
+    if (!tracker_11) return;
+    const failures_0 = tracker_11.getFailedTransactions();
+    const failure = failures_0.find((f_0) => f_0.id === failureId_0);
+    if (!failure) {
+      logger.warn("[PowerSyncProvider] Failure not found:", failureId_0);
+      return;
+    }
+    const entries_2 = tracker_11.takeFailureForRetry(failureId_0);
+    if (!entries_2 || entries_2.length === 0) return;
+    setFailedTransactions(tracker_11.getFailedTransactions());
+    if (!db || !connector) {
+      logger.warn("[PowerSyncProvider] Cannot retry - not initialized");
+      tracker_11.recordTransactionFailure(failure.entries, failure.error, failure.isPermanent, failure.affectedEntityIds, failure.affectedTables, {
+        retryCount: failure.retryCount,
+        firstFailedAt: failure.firstFailedAt
+      });
+      setFailedTransactions(tracker_11.getFailedTransactions());
+      return;
+    }
+    try {
+      if (db.connected) {
+        await db.disconnect();
+      }
+      await db.connect(connector);
+      logger.info("[PowerSyncProvider] Retry triggered for failure:", failureId_0);
+    } catch (err_5) {
+      logger.error("[PowerSyncProvider] Retry failed, re-recording failure:", err_5);
+      tracker_11.recordTransactionFailure(failure.entries, failure.error, failure.isPermanent, failure.affectedEntityIds, failure.affectedTables, {
+        retryCount: failure.retryCount,
+        firstFailedAt: failure.firstFailedAt
+      });
+      setFailedTransactions(tracker_11.getFailedTransactions());
+    }
+  }, [db, connector, logger]);
+  const powerSyncContextValue = useMemo(() => ({
+    db,
+    connector,
+    attachmentQueue,
+    isReady,
+    isInitializing,
+    attachmentQueueReady,
+    error,
+    schema,
+    platform,
+    conflictBus
+  }), [db, connector, attachmentQueue, isReady, isInitializing, attachmentQueueReady, error, schema, platform, conflictBus]);
+  const syncStatusContextValue = useMemo(() => ({
+    status: syncStatus,
+    pendingMutations,
+    pendingCount: pendingMutations.length,
+    // Expose uploading/downloading directly from syncStatus for reliable activity detection
+    isUploading: syncStatus.uploading,
+    isDownloading: syncStatus.downloading,
+    isPaused: syncModeState.mode === "offline",
+    syncMode: syncModeState.mode,
+    lastSyncedAt,
+    // Connection error for consumers to display
+    connectionError,
+    // Failed transaction fields
+    failedTransactions,
+    hasUploadErrors: failedTransactions.length > 0,
+    permanentErrorCount: failedTransactions.filter((f_1) => f_1.isPermanent).length,
+    // Clear failure functions
+    clearFailure,
+    clearAllFailures,
+    // Completed transaction fields
+    completedTransactions,
+    clearCompletedHistory,
+    // Sync mode control functions
+    setSyncMode,
+    setForceNextUpload,
+    // Discard mutation functions
+    discardPendingMutation,
+    discardAllPendingMutations,
+    // Retry control functions
+    pauseAutoRetry,
+    resumeAutoRetry
+  }), [syncStatus, pendingMutations, syncModeState.mode, lastSyncedAt, connectionError, failedTransactions, clearFailure, clearAllFailures, completedTransactions, clearCompletedHistory, setSyncMode, setForceNextUpload, discardPendingMutation, discardAllPendingMutations, pauseAutoRetry, resumeAutoRetry]);
+  const connectionHealthContextValue = useMemo(() => ({
+    health: connectionHealth
+  }), [connectionHealth]);
+  const syncMetricsContextValue = useMemo(() => ({
+    metrics: syncMetrics
+  }), [syncMetrics]);
+  const connectionStatusValue = useMemo(() => ({
+    connected: syncStatus.connected,
+    connecting: syncStatus.connecting,
+    hasSynced: syncStatus.hasSynced,
+    lastSyncedAt,
+    connectionError
+  }), [syncStatus.connected, syncStatus.connecting, syncStatus.hasSynced, lastSyncedAt, connectionError]);
+  const syncActivityValue = useMemo(() => ({
+    uploading: syncStatus.uploading,
+    downloading: syncStatus.downloading,
+    downloadProgress: syncStatus.downloadProgress
+  }), [syncStatus.uploading, syncStatus.downloading, syncStatus.downloadProgress]);
+  const pendingMutationsValue = useMemo(() => ({
+    pendingMutations,
+    pendingCount: pendingMutations.length,
+    discardPendingMutation,
+    discardAllPendingMutations,
+    addPendingMutation,
+    removePendingMutation
+  }), [pendingMutations, discardPendingMutation, discardAllPendingMutations, addPendingMutation, removePendingMutation]);
+  const failedTransactionsValue = useMemo(() => ({
+    failedTransactions,
+    hasUploadErrors: failedTransactions.length > 0,
+    permanentErrorCount: failedTransactions.filter((f_2) => f_2.isPermanent).length,
+    clearFailure,
+    clearAllFailures,
+    pauseAutoRetry,
+    resumeAutoRetry,
+    retryFailure
+  }), [failedTransactions, clearFailure, clearAllFailures, pauseAutoRetry, resumeAutoRetry, retryFailure]);
+  const completedTransactionsValue = useMemo(() => ({
+    completedTransactions,
+    clearCompletedHistory,
+    clearCompletedItem,
+    newCompletedTransactions,
+    markNotificationsAsSeen
+  }), [completedTransactions, clearCompletedHistory, clearCompletedItem, newCompletedTransactions, markNotificationsAsSeen]);
+  const syncModeValue = useMemo(() => ({
+    syncMode: syncModeState.mode,
+    isPaused: syncModeState.mode === "offline",
+    isAutoOffline,
+    networkReachable,
+    setSyncMode,
+    setForceNextUpload
+  }), [syncModeState.mode, isAutoOffline, networkReachable, setSyncMode, setForceNextUpload]);
+  return /* @__PURE__ */ jsx(PowerSyncContext.Provider, { value: powerSyncContextValue, children: /* @__PURE__ */ jsx(ConnectionStatusContext.Provider, { value: connectionStatusValue, children: /* @__PURE__ */ jsx(SyncActivityContext.Provider, { value: syncActivityValue, children: /* @__PURE__ */ jsx(PendingMutationsContext.Provider, { value: pendingMutationsValue, children: /* @__PURE__ */ jsx(FailedTransactionsContext.Provider, { value: failedTransactionsValue, children: /* @__PURE__ */ jsx(CompletedTransactionsContext.Provider, { value: completedTransactionsValue, children: /* @__PURE__ */ jsx(SyncModeContext.Provider, { value: syncModeValue, children: /* @__PURE__ */ jsx(SyncStatusContext.Provider, { value: syncStatusContextValue, children: /* @__PURE__ */ jsx(ConnectionHealthContext.Provider, { value: connectionHealthContextValue, children: /* @__PURE__ */ jsx(SyncMetricsContext.Provider, { value: syncMetricsContextValue, children: /* @__PURE__ */ jsx(AttachmentQueueContext.Provider, { value: attachmentQueue, children }) }) }) }) }) }) }) }) }) }) });
+}
+
+// src/provider/OfflineDataProvider.tsx
+import { c as _c } from "react/compiler-runtime";
+import { useEffect as useEffect3, useRef as useRef3, useState as useState2 } from "react";
+import { View, Text, StyleSheet, Pressable } from "react-native";
+
+// src/provider/ProviderBridge.tsx
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { PowerSyncContext as PowerSyncContext2 } from "@powersync/react-native";
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+function ProviderBridge({
+  children,
+  skipConflictProvider = false,
+  skipStorageQueueProvider = false,
+  backgroundSync,
+  onBackgroundSyncSystemReady,
+  onDbReady,
+  onSyncStatusChange,
+  onAddPendingMutationReady,
+  onRemovePendingMutationReady
+}) {
+  const {
+    db,
+    attachmentQueue,
+    isReady,
+    attachmentQueueReady,
+    conflictBus,
+    platform
+  } = usePowerSync();
+  const {
+    status: syncStatus
+  } = useSyncStatus();
+  const {
+    addPendingMutation,
+    removePendingMutation
+  } = usePendingMutationsContext();
+  const isOnline = useOnlineStatus();
+  const onDbReadyRef = useRef2(onDbReady);
+  const onSyncStatusChangeRef = useRef2(onSyncStatusChange);
+  useEffect2(() => {
+    onDbReadyRef.current = onDbReady;
+  }, [onDbReady]);
+  useEffect2(() => {
+    onSyncStatusChangeRef.current = onSyncStatusChange;
+  }, [onSyncStatusChange]);
+  const hasSignalledReady = useRef2(false);
+  useEffect2(() => {
+    if (!isReady) return;
+    platform.logger.debug("[ProviderBridge] Passing pending mutation functions to parent");
+    onAddPendingMutationReady(addPendingMutation);
+    onRemovePendingMutationReady(removePendingMutation);
+  }, [isReady, addPendingMutation, removePendingMutation, onAddPendingMutationReady, onRemovePendingMutationReady, platform]);
+  useEffect2(() => {
+    if (!isReady || !db) return;
+    const snapshot = {
+      hasSynced: syncStatus.hasSynced,
+      connected: syncStatus.connected,
+      connecting: syncStatus.connecting,
+      isOnline
+    };
+    if (!hasSignalledReady.current) {
+      hasSignalledReady.current = true;
+      onDbReadyRef.current(db, snapshot);
+    } else {
+      onSyncStatusChangeRef.current(snapshot);
+    }
+  }, [isReady, db, syncStatus.hasSynced, syncStatus.connected, syncStatus.connecting, isOnline]);
+  useEffect2(() => {
+    if (!isReady || !db || !backgroundSync?.enabled) return;
+    const backgroundSystem = {
+      init: async () => {
+        if (!db.connected) {
+          platform.logger.info("[Background Sync] DB not connected, waiting for connection...");
+        }
+      },
+      disconnect: async () => {
+        await db.disconnect();
+      },
+      isConnected: () => db.connected,
+      getDatabase: () => db,
+      onStatusChange: (callback) => {
+        return db.registerListener({
+          statusChanged: (status) => {
+            callback({
+              lastSyncedAt: status.lastSyncedAt ?? null,
+              downloading: status.dataFlowStatus?.downloading ?? false,
+              uploading: status.dataFlowStatus?.uploading ?? false
+            });
+          }
+        });
+      }
+    };
+    onBackgroundSyncSystemReady?.(backgroundSystem);
+    return () => {
+      onBackgroundSyncSystemReady?.(null);
+    };
+  }, [isReady, db, backgroundSync?.enabled, onBackgroundSyncSystemReady, platform]);
+  if (!isReady) {
+    return null;
+  }
+  let content = children;
+  if (!skipStorageQueueProvider) {
+    const {
+      StorageQueueProvider
+    } = __require("@pol-studios/db");
+    content = /* @__PURE__ */ jsx2(StorageQueueProvider, { attachmentQueue, isReady: attachmentQueueReady, children: content });
+  }
+  if (!skipConflictProvider) {
+    const {
+      ConflictProvider
+    } = __require("@pol-studios/db");
+    content = /* @__PURE__ */ jsx2(ConflictProvider, { conflictBus, children: content });
+  }
+  if (db) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx2(PowerSyncContext2.Provider, { value: db, children: content })
+    );
+  }
+  return /* @__PURE__ */ jsx2(Fragment, { children: content });
+}
+
+// src/provider/OfflineDataProvider.tsx
+import { Fragment as Fragment2, jsx as jsx3, jsxs } from "react/jsx-runtime";
+var defaultLogger = {
+  debug: (...args) => console.debug("[OfflineData]", ...args),
+  info: (...args) => console.info("[OfflineData]", ...args),
+  warn: (...args) => console.warn("[OfflineData]", ...args),
+  error: (...args) => console.error("[OfflineData]", ...args)
+};
+var errorStyles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: "center",
+    alignItems: "center",
+    backgroundColor: "#f5f5f5",
+    padding: 20
+  },
+  content: {
+    backgroundColor: "white",
+    borderRadius: 12,
+    padding: 24,
+    maxWidth: 400,
+    width: "100%",
+    shadowColor: "#000",
+    shadowOffset: {
+      width: 0,
+      height: 2
+    },
+    shadowOpacity: 0.1,
+    shadowRadius: 8,
+    elevation: 4
+  },
+  title: {
+    fontSize: 20,
+    fontWeight: "600",
+    color: "#1a1a1a",
+    marginBottom: 12,
+    textAlign: "center"
+  },
+  message: {
+    fontSize: 14,
+    color: "#666",
+    marginBottom: 16,
+    textAlign: "center",
+    lineHeight: 20
+  },
+  errorDetail: {
+    fontSize: 12,
+    color: "#999",
+    marginBottom: 20,
+    textAlign: "center",
+    fontFamily: "monospace"
+  },
+  retryButton: {
+    backgroundColor: "#007AFF",
+    borderRadius: 8,
+    paddingVertical: 12,
+    paddingHorizontal: 24,
+    alignItems: "center"
+  },
+  retryButtonText: {
+    color: "white",
+    fontSize: 16,
+    fontWeight: "600"
+  }
+});
+function DefaultErrorRecoveryUI(t0) {
+  const $ = _c(10);
+  const {
+    error,
+    onRetry
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t1 = /* @__PURE__ */ jsx3(Text, { style: errorStyles.title, children: "Database Error" });
+    t2 = /* @__PURE__ */ jsx3(Text, { style: errorStyles.message, children: "The local database encountered an error. This can happen if the app was interrupted during startup." });
+    $[0] = t1;
+    $[1] = t2;
+  } else {
+    t1 = $[0];
+    t2 = $[1];
+  }
+  let t3;
+  if ($[2] !== error.message) {
+    t3 = /* @__PURE__ */ jsx3(Text, { style: errorStyles.errorDetail, children: error.message });
+    $[2] = error.message;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  let t4;
+  if ($[4] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t4 = /* @__PURE__ */ jsx3(Text, { style: errorStyles.retryButtonText, children: "Retry" });
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  let t5;
+  if ($[5] !== onRetry) {
+    t5 = /* @__PURE__ */ jsx3(Pressable, { style: errorStyles.retryButton, onPress: onRetry, children: t4 });
+    $[5] = onRetry;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  let t6;
+  if ($[7] !== t3 || $[8] !== t5) {
+    t6 = /* @__PURE__ */ jsx3(View, { style: errorStyles.container, children: /* @__PURE__ */ jsxs(View, { style: errorStyles.content, children: [
+      t1,
+      t2,
+      t3,
+      t5
+    ] }) });
+    $[7] = t3;
+    $[8] = t5;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  return t6;
+}
+function OfflineDataProvider(t0) {
+  const $ = _c(109);
+  const {
+    config,
+    children,
+    dataLayer,
+    backgroundSync,
+    skipConflictProvider: t1,
+    skipStorageQueueProvider: t2,
+    storageAdapter: customStorageAdapter,
+    uploadHandler: customUploadHandler,
+    renderInitError,
+    renderError,
+    onReady,
+    onError,
+    onSyncStatusChange,
+    onBackgroundSyncSystemReady: onBackgroundSyncSystemReadyProp
+  } = t0;
+  const skipConflictProvider = t1 === void 0 ? false : t1;
+  const skipStorageQueueProvider = t2 === void 0 ? false : t2;
+  const {
+    schema,
+    supabaseClient,
+    queryClient,
+    powerSyncUrl,
+    dbFilename: t3,
+    attachments,
+    platform: customPlatform,
+    connector: connectorConfig,
+    sync: syncConfig
+  } = config;
+  const dbFilename = t3 === void 0 ? "powersync.db" : t3;
+  const [initError, setInitError] = useState2(null);
+  const [retryKey, setRetryKey] = useState2(0);
+  const [powerSyncInstance, setPowerSyncInstance] = useState2(null);
+  const [powerSyncSyncStatus, setPowerSyncSyncStatus] = useState2(void 0);
+  const addPendingMutationRef = useRef3(null);
+  const removePendingMutationRef = useRef3(null);
+  const backgroundSyncSystemRef = useRef3(null);
+  let t4;
+  if ($[0] !== customPlatform) {
+    t4 = customPlatform ?? createNativePlatformAdapter(defaultLogger);
+    $[0] = customPlatform;
+    $[1] = t4;
+  } else {
+    t4 = $[1];
+  }
+  const platform = t4;
+  let t5;
+  bb0: {
+    if (customStorageAdapter) {
+      t5 = customStorageAdapter;
+      break bb0;
+    }
+    if (!attachments) {
+      t5 = void 0;
+      break bb0;
+    }
+    let t62;
+    if ($[2] !== attachments.bucket || $[3] !== platform.fileSystem || $[4] !== supabaseClient) {
+      t62 = new SupabaseStorageAdapter({
+        client: supabaseClient,
+        bucketConfig: {
+          defaultBucket: attachments.bucket
+        }
+      }, platform.fileSystem);
+      $[2] = attachments.bucket;
+      $[3] = platform.fileSystem;
+      $[4] = supabaseClient;
+      $[5] = t62;
+    } else {
+      t62 = $[5];
+    }
+    t5 = t62;
+  }
+  const storageAdapter = t5;
+  let t10;
+  let t11;
+  let t6;
+  let t7;
+  let t8;
+  let t9;
+  if ($[6] !== platform.logger) {
+    t6 = async () => {
+      platform.logger.warn("Sync not available: Use useSyncControl from PowerSync context");
+    };
+    t7 = async () => {
+      platform.logger.warn("Live sync not available: Use useSyncControl from PowerSync context");
+    };
+    t8 = () => {
+      platform.logger.warn("Live sync not available: Use useSyncControl from PowerSync context");
+    };
+    t9 = async () => {
+      platform.logger.warn("Scope control not available: Use useSyncControl from PowerSync context");
+    };
+    t10 = async () => {
+      platform.logger.warn("Retry not available: Use useSyncControl from PowerSync context");
+    };
+    t11 = () => {
+      platform.logger.warn("Clear failed uploads not available: Use useSyncControl from PowerSync context");
+    };
+    $[6] = platform.logger;
+    $[7] = t10;
+    $[8] = t11;
+    $[9] = t6;
+    $[10] = t7;
+    $[11] = t8;
+    $[12] = t9;
+  } else {
+    t10 = $[7];
+    t11 = $[8];
+    t6 = $[9];
+    t7 = $[10];
+    t8 = $[11];
+    t9 = $[12];
+  }
+  let t12;
+  if ($[13] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t12 = [];
+    $[13] = t12;
+  } else {
+    t12 = $[13];
+  }
+  let t13;
+  let t14;
+  if ($[14] !== platform.logger) {
+    t13 = () => {
+      platform.logger.warn("Pause auto-retry not available: Use useSyncControl from PowerSync context");
+    };
+    t14 = () => {
+      platform.logger.warn("Resume auto-retry not available: Use useSyncControl from PowerSync context");
+    };
+    $[14] = platform.logger;
+    $[15] = t13;
+    $[16] = t14;
+  } else {
+    t13 = $[15];
+    t14 = $[16];
+  }
+  let t15;
+  let t16;
+  if ($[17] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t15 = (entry) => {
+      if (addPendingMutationRef.current) {
+        addPendingMutationRef.current(entry);
+      }
+    };
+    t16 = (id) => {
+      if (removePendingMutationRef.current) {
+        removePendingMutationRef.current(id);
+      }
+    };
+    $[17] = t15;
+    $[18] = t16;
+  } else {
+    t15 = $[17];
+    t16 = $[18];
+  }
+  let t17;
+  if ($[19] !== t10 || $[20] !== t11 || $[21] !== t13 || $[22] !== t14 || $[23] !== t6 || $[24] !== t7 || $[25] !== t8 || $[26] !== t9) {
+    t17 = {
+      triggerSync: t6,
+      startLiveSync: t7,
+      stopLiveSync: t8,
+      setScope: t9,
+      retryFailedUploads: t10,
+      clearFailedUploads: t11,
+      failedUploads: t12,
+      pauseAutoRetry: t13,
+      resumeAutoRetry: t14,
+      isAutoRetryPaused: false,
+      addPendingMutation: t15,
+      removePendingMutation: t16
+    };
+    $[19] = t10;
+    $[20] = t11;
+    $[21] = t13;
+    $[22] = t14;
+    $[23] = t6;
+    $[24] = t7;
+    $[25] = t8;
+    $[26] = t9;
+    $[27] = t17;
+  } else {
+    t17 = $[27];
+  }
+  const syncControl = t17;
+  let t18;
+  bb1: {
+    if (!attachments) {
+      t18 = void 0;
+      break bb1;
+    }
+    let t192;
+    if ($[28] !== attachments.idColumn || $[29] !== attachments.orderByColumn || $[30] !== attachments.projectFilter || $[31] !== attachments.sourceTable) {
+      t192 = {
+        table: attachments.sourceTable,
+        idColumn: attachments.idColumn,
+        orderByColumn: attachments.orderByColumn,
+        projectFilter: attachments.projectFilter
+      };
+      $[28] = attachments.idColumn;
+      $[29] = attachments.orderByColumn;
+      $[30] = attachments.projectFilter;
+      $[31] = attachments.sourceTable;
+      $[32] = t192;
+    } else {
+      t192 = $[32];
+    }
+    let t202;
+    if ($[33] !== platform.logger) {
+      t202 = async (attachment, error) => {
+        platform.logger.warn(`[AttachmentQueue] Download failed for ${attachment.filename}:`, error);
+        return {
+          retry: true
+        };
+      };
+      $[33] = platform.logger;
+      $[34] = t202;
+    } else {
+      t202 = $[34];
+    }
+    let t212;
+    if ($[35] !== customUploadHandler) {
+      t212 = customUploadHandler ? {
+        handler: customUploadHandler,
+        config: {
+          concurrency: 3,
+          timeoutMs: 12e4,
+          baseRetryDelayMs: 5e3,
+          maxRetryDelayMs: 36e5,
+          staleDaysThreshold: 7
+        }
+      } : void 0;
+      $[35] = customUploadHandler;
+      $[36] = t212;
+    } else {
+      t212 = $[36];
+    }
+    let t222;
+    if ($[37] !== storageAdapter || $[38] !== t192 || $[39] !== t202 || $[40] !== t212) {
+      t222 = {
+        source: t192,
+        remoteStorage: storageAdapter,
+        attachmentTableName: "photo_attachments",
+        performInitialSync: true,
+        onDownloadError: t202,
+        upload: t212
+      };
+      $[37] = storageAdapter;
+      $[38] = t192;
+      $[39] = t202;
+      $[40] = t212;
+      $[41] = t222;
+    } else {
+      t222 = $[41];
+    }
+    t18 = t222;
+  }
+  const attachmentConfig = t18;
+  const t19 = powerSyncUrl ?? "";
+  const t20 = syncConfig?.autoConnect ?? true;
+  const t21 = syncConfig?.enableHealthMonitoring ?? true;
+  const t22 = syncConfig?.enableMetrics ?? true;
+  let t23;
+  if ($[42] !== t20 || $[43] !== t21 || $[44] !== t22) {
+    t23 = {
+      autoConnect: t20,
+      enableHealthMonitoring: t21,
+      enableMetrics: t22
+    };
+    $[42] = t20;
+    $[43] = t21;
+    $[44] = t22;
+    $[45] = t23;
+  } else {
+    t23 = $[45];
+  }
+  let t24;
+  if ($[46] !== attachmentConfig || $[47] !== connectorConfig || $[48] !== dbFilename || $[49] !== platform || $[50] !== queryClient || $[51] !== schema || $[52] !== supabaseClient || $[53] !== t19 || $[54] !== t23) {
+    t24 = {
+      platform,
+      schema,
+      powerSyncUrl: t19,
+      supabaseClient,
+      queryClient,
+      dbFilename,
+      connector: connectorConfig,
+      attachments: attachmentConfig,
+      sync: t23
+    };
+    $[46] = attachmentConfig;
+    $[47] = connectorConfig;
+    $[48] = dbFilename;
+    $[49] = platform;
+    $[50] = queryClient;
+    $[51] = schema;
+    $[52] = supabaseClient;
+    $[53] = t19;
+    $[54] = t23;
+    $[55] = t24;
+  } else {
+    t24 = $[55];
+  }
+  const powerSyncConfig = t24;
+  let t25;
+  if ($[56] !== onError || $[57] !== platform.logger) {
+    t25 = (err) => {
+      platform.logger.error("PowerSync error:", err);
+      const errorMessage = err.message ?? "";
+      if (errorMessage.includes("not open") || errorMessage.includes("closed") || errorMessage.includes("failed to open") || errorMessage.includes("initialization failed")) {
+        setInitError(err);
+      }
+      onError?.(err);
+    };
+    $[56] = onError;
+    $[57] = platform.logger;
+    $[58] = t25;
+  } else {
+    t25 = $[58];
+  }
+  const handlePowerSyncError = t25;
+  let t26;
+  if ($[59] !== platform.logger) {
+    t26 = () => {
+      platform.logger.info("Retrying PowerSync initialization...");
+      setInitError(null);
+      setRetryKey(_temp);
+    };
+    $[59] = platform.logger;
+    $[60] = t26;
+  } else {
+    t26 = $[60];
+  }
+  const handleRetry = t26;
+  let t27;
+  if ($[61] !== backgroundSync?.callbacks || $[62] !== onBackgroundSyncSystemReadyProp || $[63] !== platform.logger) {
+    t27 = (system) => {
+      backgroundSyncSystemRef.current = system;
+      backgroundSync?.callbacks?.onSyncStart?.();
+      onBackgroundSyncSystemReadyProp?.(system);
+      platform.logger.info("[Background Sync] System ready");
+    };
+    $[61] = backgroundSync?.callbacks;
+    $[62] = onBackgroundSyncSystemReadyProp;
+    $[63] = platform.logger;
+    $[64] = t27;
+  } else {
+    t27 = $[64];
+  }
+  backgroundSync?.callbacks;
+  const handleBackgroundSyncSystemReady = t27;
+  let t28;
+  if ($[65] !== renderError || $[66] !== renderInitError) {
+    t28 = (error_0, retry) => {
+      const customRenderer = renderInitError ?? renderError;
+      if (customRenderer) {
+        return customRenderer(error_0, retry);
+      }
+      return /* @__PURE__ */ jsx3(DefaultErrorRecoveryUI, { error: error_0, onRetry: retry });
+    };
+    $[65] = renderError;
+    $[66] = renderInitError;
+    $[67] = t28;
+  } else {
+    t28 = $[67];
+  }
+  const errorFallback = t28;
+  let t29;
+  if ($[68] !== powerSyncSyncStatus || $[69] !== powerSyncUrl) {
+    t29 = !powerSyncUrl ? {
+      hasSynced: true,
+      connected: true,
+      connecting: false,
+      isOnline: true
+    } : powerSyncSyncStatus;
+    $[68] = powerSyncSyncStatus;
+    $[69] = powerSyncUrl;
+    $[70] = t29;
+  } else {
+    t29 = $[70];
+  }
+  const effectiveSyncStatus = t29;
+  let t30;
+  let t31;
+  if ($[71] !== effectiveSyncStatus || $[72] !== onSyncStatusChange) {
+    t30 = () => {
+      if (effectiveSyncStatus) {
+        onSyncStatusChange?.(effectiveSyncStatus);
+      }
+    };
+    t31 = [effectiveSyncStatus, onSyncStatusChange];
+    $[71] = effectiveSyncStatus;
+    $[72] = onSyncStatusChange;
+    $[73] = t30;
+    $[74] = t31;
+  } else {
+    t30 = $[73];
+    t31 = $[74];
+  }
+  useEffect3(t30, t31);
+  let t32;
+  let t33;
+  if ($[75] !== backgroundSync || $[76] !== children || $[77] !== dataLayer || $[78] !== effectiveSyncStatus || $[79] !== errorFallback || $[80] !== handleBackgroundSyncSystemReady || $[81] !== handlePowerSyncError || $[82] !== handleRetry || $[83] !== initError || $[84] !== onError || $[85] !== onReady || $[86] !== platform.logger || $[87] !== powerSyncConfig || $[88] !== powerSyncInstance || $[89] !== powerSyncUrl || $[90] !== queryClient || $[91] !== renderError || $[92] !== renderInitError || $[93] !== retryKey || $[94] !== skipConflictProvider || $[95] !== skipStorageQueueProvider || $[96] !== supabaseClient || $[97] !== syncControl) {
+    t33 = /* @__PURE__ */ Symbol.for("react.early_return_sentinel");
+    bb2: {
+      const renderContent = () => {
+        if (!powerSyncUrl) {
+          return /* @__PURE__ */ jsx3(Fragment2, { children });
+        }
+        if (initError) {
+          const customRenderer_0 = renderInitError ?? renderError;
+          if (customRenderer_0) {
+            return /* @__PURE__ */ jsx3(Fragment2, { children: customRenderer_0(initError, handleRetry) });
+          }
+          return /* @__PURE__ */ jsx3(DefaultErrorRecoveryUI, { error: initError, onRetry: handleRetry });
+        }
+        return /* @__PURE__ */ jsx3(PowerSyncErrorBoundary, { fallback: errorFallback, onError: handlePowerSyncError, children: /* @__PURE__ */ jsx3(PowerSyncProvider, { config: powerSyncConfig, onReady: () => {
+          platform.logger.info("PowerSync initialized and ready");
+          setInitError(null);
+          onReady?.();
+        }, onError: handlePowerSyncError, children: /* @__PURE__ */ jsx3(ProviderBridge, { skipConflictProvider, skipStorageQueueProvider, backgroundSync, onBackgroundSyncSystemReady: handleBackgroundSyncSystemReady, onDbReady: (db, syncStatus) => {
+          setPowerSyncInstance(db);
+          setPowerSyncSyncStatus(syncStatus);
+        }, onSyncStatusChange: (syncStatus_0) => {
+          setPowerSyncSyncStatus(syncStatus_0);
+        }, onAddPendingMutationReady: (add) => {
+          addPendingMutationRef.current = add;
+        }, onRemovePendingMutationReady: (remove) => {
+          removePendingMutationRef.current = remove;
+        }, children }) }, retryKey) });
+      };
+      let t34;
+      if ($[100] !== dataLayer.config || $[101] !== effectiveSyncStatus || $[102] !== onError || $[103] !== platform.logger || $[104] !== powerSyncInstance || $[105] !== queryClient || $[106] !== supabaseClient || $[107] !== syncControl) {
+        t34 = (content) => {
+          const {
+            DataLayerProvider
+          } = __require("@pol-studios/db");
+          return /* @__PURE__ */ jsx3(DataLayerProvider, { config: dataLayer.config, powerSyncInstance, supabaseClient, queryClient, powerSyncSyncStatus: effectiveSyncStatus, syncControl, onInitialized: () => {
+            platform.logger.info("Data layer initialized");
+          }, onError: (err_0) => {
+            platform.logger.error("Data layer error:", err_0);
+            onError?.(err_0);
+          }, children: content });
+        };
+        $[100] = dataLayer.config;
+        $[101] = effectiveSyncStatus;
+        $[102] = onError;
+        $[103] = platform.logger;
+        $[104] = powerSyncInstance;
+        $[105] = queryClient;
+        $[106] = supabaseClient;
+        $[107] = syncControl;
+        $[108] = t34;
+      } else {
+        t34 = $[108];
+      }
+      const renderWithDataLayer = t34;
+      if (dataLayer && !dataLayer.skip) {
+        t33 = renderWithDataLayer(renderContent());
+        break bb2;
+      }
+      t32 = renderContent();
+    }
+    $[75] = backgroundSync;
+    $[76] = children;
+    $[77] = dataLayer;
+    $[78] = effectiveSyncStatus;
+    $[79] = errorFallback;
+    $[80] = handleBackgroundSyncSystemReady;
+    $[81] = handlePowerSyncError;
+    $[82] = handleRetry;
+    $[83] = initError;
+    $[84] = onError;
+    $[85] = onReady;
+    $[86] = platform.logger;
+    $[87] = powerSyncConfig;
+    $[88] = powerSyncInstance;
+    $[89] = powerSyncUrl;
+    $[90] = queryClient;
+    $[91] = renderError;
+    $[92] = renderInitError;
+    $[93] = retryKey;
+    $[94] = skipConflictProvider;
+    $[95] = skipStorageQueueProvider;
+    $[96] = supabaseClient;
+    $[97] = syncControl;
+    $[98] = t32;
+    $[99] = t33;
+  } else {
+    t32 = $[98];
+    t33 = $[99];
+  }
+  if (t33 !== /* @__PURE__ */ Symbol.for("react.early_return_sentinel")) {
+    return t33;
+  }
+  return t32;
+}
+function _temp(prev) {
+  return prev + 1;
+}
+
+export {
+  ConflictBus,
+  PowerSyncProvider,
+  ProviderBridge,
+  OfflineDataProvider
+};
+//# sourceMappingURL=chunk-BREGB4WL.js.map