@pol-studios/db 1.0.50 → 1.0.52

package/dist/{chunk-7CLN4ORU.js → chunk-EOJGUOJR.js}

@@ -1,6 +1,6 @@
 import {
   useDbUpsert
-} from "./chunk-RJIVXO4U.js";
+} from "./chunk-3Q74DK5K.js";
 import {
   normalizeFilter
 } from "./chunk-Z3EJX3VG.js";
@@ -9,10 +9,10 @@ import {
 } from "./chunk-7SCJNYTE.js";
 import {
   useDbQuery
-} from "./chunk-DKUF2FKB.js";
+} from "./chunk-DP3YEVSX.js";
 import {
   useDataLayerCoreOptional
-} from "./chunk-AIYPSXIO.js";
+} from "./chunk-WQLIGVQR.js";
 import {
   getSupabaseUrl
 } from "./chunk-GC3TBUWE.js";
@@ -4143,334 +4143,6 @@ var ADAPTER_STRATEGIES = {
   AUTO: "auto"
 };
 
-// src/adapters/auto-detector.ts
-var BackendStatus = /* @__PURE__ */ ((BackendStatus2) => {
-  BackendStatus2["AVAILABLE"] = "available";
-  BackendStatus2["INITIALIZING"] = "initializing";
-  BackendStatus2["UNAVAILABLE"] = "unavailable";
-  return BackendStatus2;
-})(BackendStatus || {});
-var AdapterAutoDetector = class {
-  constructor(powerSyncDb, supabase, options = {}) {
-    this.powerSyncDb = powerSyncDb;
-    this.supabase = supabase;
-    this.options = {
-      preferPowerSync: options.preferPowerSync ?? true,
-      statusCheckTimeout: options.statusCheckTimeout ?? 1e3,
-      useOnlineUntilSynced: options.useOnlineUntilSynced ?? true
-    };
-  }
-  options;
-  listeners = /* @__PURE__ */ new Set();
-  lastResult = null;
-  syncStatus = null;
-  /**
-   * Update the PowerSync database reference.
-   * Called when PowerSync becomes available after initial construction.
-   *
-   * @param db - PowerSync database instance or null
-   */
-  setPowerSyncDb(db) {
-    this.powerSyncDb = db;
-    if (db) {
-      this.detect();
-    }
-  }
-  /**
-   * Update the sync status from PowerSync.
-   * Called when sync status changes to re-evaluate backend recommendation.
-   *
-   * @param status - Current sync status or null if not available
-   */
-  updateSyncStatus(status) {
-    const hadSynced = this.syncStatus?.hasSynced;
-    const hasSyncedNow = status?.hasSynced;
-    const changed = hadSynced !== hasSyncedNow;
-    this.syncStatus = status;
-    if (changed) {
-      this.detect();
-    }
-  }
-  /**
-   * Get current sync status.
-   * @returns Current sync status or null
-   */
-  getSyncStatus() {
-    return this.syncStatus;
-  }
-  // ===========================================================================
-  // Main Detection Methods
-  // ===========================================================================
-  /**
-   * Detect backend availability and recommend best option.
-   *
-   * The detection logic follows this priority:
-   * 1. If preferPowerSync is true and PowerSync is available, use PowerSync
-   * 2. If PowerSync is initializing and online with Supabase available, use Supabase temporarily
-   * 3. If online with Supabase available, use Supabase
-   * 4. If offline but PowerSync available, use PowerSync (offline mode)
-   * 5. If offline and PowerSync exists (even if initializing), use PowerSync local data
-   * 6. Default to Supabase as fallback
-   *
-   * @returns Detection result with recommendation and reasoning
-   */
-  detect() {
-    const result = this.performDetection();
-    if (this.hasResultChanged(result)) {
-      this.lastResult = result;
-      this.notifyListeners(result);
-    }
-    return result;
-  }
-  /**
-   * Detect backend availability WITHOUT notifying listeners.
-   *
-   * This method is safe to call during React's render phase because it does not
-   * trigger state updates in other components. Use this method when you need to
-   * check backend status synchronously during render (e.g., in getAdapter()).
-   *
-   * The regular detect() method with listener notifications should only be called
-   * from useEffect or event handlers to avoid the React warning:
-   * "Cannot update a component while rendering a different component"
-   *
-   * @returns Detection result with recommendation and reasoning
-   */
-  detectSilent() {
-    const result = this.performDetection();
-    this.lastResult = result;
-    return result;
-  }
-  /**
-   * Internal detection logic shared by detect() and detectSilent().
-   * @private
-   */
-  performDetection() {
-    const powerSyncStatus = this.detectPowerSyncStatus();
-    const supabaseStatus = this.detectSupabaseStatus();
-    const isOnline = this.checkOnlineStatus();
-    let recommendedBackend;
-    let reason;
-    if (this.options.preferPowerSync && powerSyncStatus === "available" /* AVAILABLE */) {
-      recommendedBackend = "powersync";
-      reason = "PowerSync is available and preferred for offline-first experience";
-    } else if (powerSyncStatus === "initializing" /* INITIALIZING */ && isOnline && supabaseStatus === "available" /* AVAILABLE */) {
-      recommendedBackend = "supabase";
-      reason = "PowerSync initial sync in progress; using Supabase for fresh data";
-    } else if (supabaseStatus === "available" /* AVAILABLE */ && isOnline) {
-      recommendedBackend = "supabase";
-      reason = "Using Supabase direct connection";
-    } else if (powerSyncStatus === "available" /* AVAILABLE */) {
-      recommendedBackend = "powersync";
-      reason = "Offline mode using PowerSync local data";
-    } else if (!isOnline && this.powerSyncDb) {
-      recommendedBackend = "powersync";
-      reason = "Offline mode - using PowerSync local data (initial sync may be incomplete)";
-    } else {
-      recommendedBackend = "supabase";
-      reason = "No confirmed available backend; defaulting to Supabase";
-    }
-    return {
-      powerSyncStatus,
-      supabaseStatus,
-      recommendedBackend,
-      isOnline,
-      reason
-    };
-  }
-  /**
-   * Check if PowerSync is available.
-   *
-   * PowerSync status depends on:
-   * 1. Database instance exists
-   * 2. If useOnlineUntilSynced is true, also checks if initial sync completed
-   *
-   * @returns PowerSync backend status
-   */
-  detectPowerSyncStatus() {
-    if (!this.powerSyncDb) {
-      return "unavailable" /* UNAVAILABLE */;
-    }
-    try {
-      if (typeof this.powerSyncDb.getAll !== "function") {
-        return "initializing" /* INITIALIZING */;
-      }
-      if (this.options.useOnlineUntilSynced) {
-        if (!this.syncStatus || !this.syncStatus.hasSynced) {
-          return "initializing" /* INITIALIZING */;
-        }
-      }
-      return "available" /* AVAILABLE */;
-    } catch {
-      return "initializing" /* INITIALIZING */;
-    }
-  }
-  /**
-   * Check if Supabase is available.
-   *
-   * Supabase is considered available if we have a client instance.
-   * The actual network connectivity is checked separately via checkOnlineStatus().
-   *
-   * @returns Supabase backend status
-   */
-  detectSupabaseStatus() {
-    if (!this.supabase) {
-      return "unavailable" /* UNAVAILABLE */;
-    }
-    try {
-      if (typeof this.supabase.from === "function") {
-        return "available" /* AVAILABLE */;
-      }
-      return "unavailable" /* UNAVAILABLE */;
-    } catch {
-      return "unavailable" /* UNAVAILABLE */;
-    }
-  }
-  /**
-   * Check if device is online.
-   *
-   * Prefers the sync status's isOnline property if available (from React Native NetInfo).
-   * Falls back to navigator.onLine in browser environments.
-   * Returns false by default for non-browser environments (React Native, Node.js, etc.)
-   * to ensure offline-first behavior works correctly.
-   *
-   * @returns Whether the device has network connectivity
-   */
-  checkOnlineStatus() {
-    if (this.syncStatus?.isOnline !== void 0) {
-      return this.syncStatus.isOnline;
-    }
-    if (typeof window !== "undefined" && typeof navigator !== "undefined") {
-      return navigator.onLine;
-    }
-    return false;
-  }
-  // ===========================================================================
-  // Instance Management Methods
-  // ===========================================================================
-  /**
-   * Update PowerSync instance (e.g., when it becomes available).
-   *
-   * @param db - New PowerSync database instance or null
-   */
-  setPowerSync(db) {
-    this.powerSyncDb = db;
-  }
-  /**
-   * Update Supabase instance.
-   *
-   * @param supabase - New Supabase client instance or null
-   */
-  setSupabase(supabase) {
-    this.supabase = supabase;
-  }
-  /**
-   * Get current PowerSync instance.
-   *
-   * @returns Current PowerSync database instance or null
-   */
-  getPowerSync() {
-    return this.powerSyncDb;
-  }
-  /**
-   * Get current Supabase instance.
-   *
-   * @returns Current Supabase client instance or null
-   */
-  getSupabase() {
-    return this.supabase;
-  }
-  // ===========================================================================
-  // Options Management
-  // ===========================================================================
-  /**
-   * Update detector options.
-   *
-   * @param options - New options to merge with existing
-   */
-  setOptions(options) {
-    this.options = {
-      ...this.options,
-      ...options
-    };
-  }
-  /**
-   * Get current detector options.
-   *
-   * @returns Current detector options
-   */
-  getOptions() {
-    return {
-      ...this.options
-    };
-  }
-  // ===========================================================================
-  // Listener Management
-  // ===========================================================================
-  /**
-   * Add a listener for backend change events.
-   *
-   * @param listener - Callback to invoke when detection result changes
-   * @returns Function to remove the listener
-   */
-  addListener(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  /**
-   * Remove a listener for backend change events.
-   *
-   * @param listener - Listener to remove
-   */
-  removeListener(listener) {
-    this.listeners.delete(listener);
-  }
-  /**
-   * Get the last detection result.
-   *
-   * @returns Last detection result or null if never detected
-   */
-  getLastResult() {
-    return this.lastResult;
-  }
-  // ===========================================================================
-  // Private Helper Methods
-  // ===========================================================================
-  /**
-   * Check if the detection result has changed from the last result.
-   */
-  hasResultChanged(result) {
-    if (!this.lastResult) {
-      return true;
-    }
-    return this.lastResult.powerSyncStatus !== result.powerSyncStatus || this.lastResult.supabaseStatus !== result.supabaseStatus || this.lastResult.recommendedBackend !== result.recommendedBackend || this.lastResult.isOnline !== result.isOnline;
-  }
-  /**
-   * Notify all listeners of a detection result change.
-   */
-  notifyListeners(result) {
-    const isDev = typeof __DEV__ !== "undefined" ? __DEV__ : process.env.NODE_ENV !== "production";
-    if (isDev) {
-      const prevBackend = this.lastResult?.recommendedBackend;
-      if (prevBackend && prevBackend !== result.recommendedBackend) {
-        console.log(`[DataLayer] Backend switched: ${prevBackend} \u2192 ${result.recommendedBackend}`, `| Reason: ${result.reason}`);
-      }
-      if (result.recommendedBackend === "supabase" && this.options.preferPowerSync) {
-        console.log(`[DataLayer] Using online fallback (Supabase)`, `| PowerSync: ${result.powerSyncStatus}`, `| Online: ${result.isOnline}`, `| Reason: ${result.reason}`);
-      }
-    }
-    Array.from(this.listeners).forEach((listener) => {
-      try {
-        listener(result);
-      } catch (error) {
-        console.error("Error in backend change listener:", error);
-      }
-    });
-  }
-};
-function createAdapterAutoDetector(powerSyncDb, supabase, options) {
-  return new AdapterAutoDetector(powerSyncDb, supabase, options);
-}
-
 // src/adapters/sync-tracking-adapter.ts
 var DEBUG_SYNC_TRACKING_VERBOSE = false;
 function debugLog(message, ...args) {
@@ -4613,497 +4285,813 @@ var AdapterRegistry = class {
   /**
    * Create a new adapter registry
    *
-   * @param config - Data layer configuration with table strategies
+   * @param config - Data layer configuration with table strategies
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Cache of created adapters by table name
+   */
+  adapters = /* @__PURE__ */ new Map();
+  /**
+   * PowerSync adapter instance (set during initialization or lazily via getter)
+   */
+  powerSyncAdapter = null;
+  /**
+   * Getter function to retrieve PowerSync database instance.
+   * Used for lazy initialization when PowerSync becomes available after registry creation.
+   */
+  powerSyncGetter = null;
+  /**
+   * Factory function to create PowerSync adapter from database instance.
+   * Set via setPowerSyncGetter along with the getter.
+   */
+  powerSyncAdapterFactory = null;
+  /**
+   * Supabase adapter instance (set during initialization)
+   */
+  supabaseAdapter = null;
+  /**
+   * Cached adapter instance (wraps Supabase with TanStack Query)
+   */
+  cachedAdapter = null;
+  /**
+   * Dependencies for creating adapters
+   */
+  deps = null;
+  /**
+   * Whether the registry has been initialized with adapters
+   */
+  _isInitialized = false;
+  /**
+   * Auto-detector instance for automatic backend selection
+   */
+  autoDetector = null;
+  /**
+   * Sync tracker for mutation tracking
+   */
+  syncTracker = null;
+  /**
+   * Sync tracking adapter that wraps PowerSync adapter
+   */
+  syncTrackingAdapter = null;
+  /**
+   * Listeners for backend change events
+   */
+  backendChangeListeners = /* @__PURE__ */ new Set();
+  /**
+   * Last auto-detection result for debugging and status
+   */
+  lastDetectionResult = null;
+  // ===========================================================================
+  // Initialization
+  // ===========================================================================
+  /**
+   * Check if the registry has been initialized
+   */
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  /**
+   * Initialize the registry with dependencies.
+   * Called by DataLayerProvider when PowerSync and Supabase are ready.
+   *
+   * @param deps - Dependencies needed to create adapters
+   */
+  initialize(deps) {
+    this.deps = deps;
+    this._isInitialized = true;
+  }
+  /**
+   * Set the PowerSync adapter instance
+   *
+   * @param adapter - PowerSync adapter implementation
+   */
+  setPowerSyncAdapter(adapter) {
+    this.powerSyncAdapter = adapter;
+    if (this.syncTracker) {
+      this.syncTrackingAdapter = new SyncTrackingAdapter(adapter, this.syncTracker);
+    } else {
+      this.syncTrackingAdapter = null;
+    }
+    this.adapters.clear();
+  }
+  /**
+   * Set a getter function for lazy PowerSync adapter initialization.
+   *
+   * This allows the registry to lazily create the PowerSync adapter when
+   * PowerSync becomes available, rather than requiring it at initialization time.
+   * Solves race conditions where queries/mutations run before PowerSync is ready.
+   *
+   * @param getter - Function that returns the PowerSync database instance (or null if not ready)
+   * @param factory - Function that creates a TableDataAdapter from the database instance
+   */
+  setPowerSyncGetter(getter, factory) {
+    this.powerSyncGetter = getter;
+    this.powerSyncAdapterFactory = factory;
+  }
+  /**
+   * Ensure PowerSync adapter is initialized if available.
+   *
+   * Checks the getter (if set) and lazily creates the adapter if PowerSync
+   * is now available. Also updates the auto-detector with the new reference.
+   *
+   * @returns true if PowerSync adapter is available, false otherwise
+   */
+  ensurePowerSyncAdapter() {
+    if (this.powerSyncAdapter) {
+      return true;
+    }
+    if (!this.powerSyncGetter || !this.powerSyncAdapterFactory) {
+      return false;
+    }
+    const db = this.powerSyncGetter();
+    if (!db) {
+      return false;
+    }
+    const adapter = this.powerSyncAdapterFactory(db);
+    this.setPowerSyncAdapter(adapter);
+    if (this.autoDetector) {
+      this.autoDetector.setPowerSyncDb(db);
+    }
+    return true;
+  }
+  /**
+   * Set the sync tracker for mutation tracking.
+   * When set, write operations on PowerSync tables will
+   * automatically track pending mutations.
+   *
+   * NOTE: This also clears the adapter cache to ensure any
+   * previously cached adapters (which may have been created
+   * before the sync tracker was available) are recreated
+   * with the new sync tracker on next access.
+   */
+  setSyncTracker(tracker) {
+    this.syncTracker = tracker;
+    if (this.powerSyncAdapter) {
+      this.syncTrackingAdapter = new SyncTrackingAdapter(this.powerSyncAdapter, tracker);
+    }
+    this.adapters.clear();
+  }
+  /**
+   * Set the Supabase adapter instance
+   *
+   * @param adapter - Supabase adapter implementation
+   */
+  setSupabaseAdapter(adapter) {
+    this.supabaseAdapter = adapter;
+  }
+  /**
+   * Set the Cached adapter instance
+   *
+   * @param adapter - Cached adapter implementation
+   */
+  setCachedAdapter(adapter) {
+    this.cachedAdapter = adapter;
+  }
+  /**
+   * Initialize auto-detection with a detector instance
+   *
+   * @param detector - The auto-detector to use
+   */
+  initializeAutoDetection(detector) {
+    this.autoDetector = detector;
+    detector.addListener((result) => {
+      this.lastDetectionResult = result;
+      this.notifyBackendChange(result.recommendedBackend);
+    });
+  }
+  // ===========================================================================
+  // Adapter Access
+  // ===========================================================================
+  /**
+   * Get the appropriate adapter for a table based on configuration.
+   *
+   * The adapter is selected based on the table's strategy in config.tables:
+   * - "powersync": Returns PowerSyncAdapter
+   * - "supabase": Returns SupabaseAdapter
+   * - "cached": Returns CachedAdapter (wrapping Supabase)
+   * - "hybrid": Returns HybridAdapter (combining PowerSync + Cached)
+   * - "auto": Uses auto-detection to select the best backend
+   *
+   * For tables not in config, defaults to auto-detection if available,
+   * otherwise falls back to SupabaseAdapter.
+   *
+   * Supports schema-qualified table names:
+   * - "core.Profile" looks up config["core.Profile"] first, then config["Profile"]
+   * - Auto-generates PowerSync alias as "CoreProfile" if not explicitly set
+   *
+   * @param table - The table name (may be schema-qualified like "core.Profile")
+   * @param operation - The operation type: 'read' uses fallback logic during init, 'write' always uses PowerSync for powersync tables
+   * @returns The appropriate adapter for the table
+   * @throws Error if adapters are not initialized
+   */
+  getAdapter(table, _operation = "read") {
+    this.ensurePowerSyncAdapter();
+    const tableWithoutSchema = table.includes(".") ? table.split(".")[1] : table;
+    const strategy = this.config.tables[table] ?? this.config.tables[tableWithoutSchema];
+    if (!strategy || strategy.strategy === "auto") {
+      if (this.powerSyncAdapter) {
+        const powerSyncTableKeys = this.getPowerSyncTableKeys();
+        const isConfigured = powerSyncTableKeys.some((key) => key === table || key === tableWithoutSchema || key.includes(".") && key.split(".")[1] === tableWithoutSchema);
+        if (!isConfigured) {
+          if (this.supabaseAdapter) {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              console.warn(`[AdapterRegistry] Table "${table}" is not configured for PowerSync sync. Using Supabase fallback.`);
+            }
+            return this.supabaseAdapter;
+          }
+          throw new Error(`Table "${table}" is not configured for PowerSync sync and Supabase adapter is not available. Either add this table to the PowerSync schema or initialize the Supabase adapter.`);
+        }
+      }
+      return this.getAutoAdapter(strategy, table);
+    }
+    if (strategy.strategy === "powersync") {
+      if (this.powerSyncAdapter) {
+        return this.syncTrackingAdapter ?? this.powerSyncAdapter;
+      }
+      if (this.supabaseAdapter) {
+        return this.supabaseAdapter;
+      }
+    }
+    const existing = this.adapters.get(table);
+    if (existing) {
+      return existing;
+    }
+    const adapter = this.createAdapter(strategy);
+    this.adapters.set(table, adapter);
+    return adapter;
+  }
+  /**
+   * Get the PowerSync adapter directly
+   *
+   * @returns PowerSync adapter or null if not initialized
    */
-  constructor(config) {
-    this.config = config;
+  getPowerSyncAdapter() {
+    return this.powerSyncAdapter;
   }
   /**
-   * Cache of created adapters by table name
+   * Get the Supabase adapter directly
+   *
+   * @returns Supabase adapter or null if not initialized
    */
-  adapters = /* @__PURE__ */ new Map();
+  getSupabaseAdapter() {
+    return this.supabaseAdapter;
+  }
   /**
-   * PowerSync adapter instance (set during initialization or lazily via getter)
+   * Get the Cached adapter directly
+   *
+   * @returns Cached adapter or null if not initialized
    */
-  powerSyncAdapter = null;
+  getCachedAdapter() {
+    return this.cachedAdapter;
+  }
   /**
-   * Getter function to retrieve PowerSync database instance.
-   * Used for lazy initialization when PowerSync becomes available after registry creation.
+   * Get all configured table names
+   *
+   * @returns Array of table names with explicit strategy configuration
    */
-  powerSyncGetter = null;
+  getConfiguredTables() {
+    return Object.keys(this.config.tables);
+  }
   /**
-   * Factory function to create PowerSync adapter from database instance.
-   * Set via setPowerSyncGetter along with the getter.
+   * Get the strategy for a specific table
+   *
+   * @param table - The table name (may include schema prefix like "core.Profile")
+   * @returns The table strategy or undefined if not configured
    */
-  powerSyncAdapterFactory = null;
+  getTableStrategy(table) {
+    const tableWithoutSchema = table.includes(".") ? table.split(".")[1] : table;
+    return this.config.tables[table] ?? this.config.tables[tableWithoutSchema];
+  }
   /**
-   * Supabase adapter instance (set during initialization)
+   * Check if a table uses PowerSync strategy
+   *
+   * @param table - The table name (may include schema prefix like "core.Profile")
+   * @returns True if table uses PowerSync, Hybrid, or Auto strategy
    */
-  supabaseAdapter = null;
+  usesPowerSync(table) {
+    const strategy = this.getTableStrategy(table);
+    return strategy?.strategy === "powersync" || strategy?.strategy === "hybrid" || strategy?.strategy === "auto";
+  }
   /**
-   * Cached adapter instance (wraps Supabase with TanStack Query)
+   * Get all table config keys that use PowerSync (may be schema-qualified)
+   *
+   * @returns Array of config keys using PowerSync, Hybrid, or Auto strategy
    */
-  cachedAdapter = null;
+  getPowerSyncTableKeys() {
+    return Object.entries(this.config.tables).filter(([_, strategy]) => strategy.strategy === "powersync" || strategy.strategy === "hybrid" || strategy.strategy === "auto").map(([key]) => key);
+  }
   /**
-   * Dependencies for creating adapters
+   * Get all tables that use PowerSync (returns aliases for PowerSync schema)
+   *
+   * @returns Array of PowerSync table aliases
    */
-  deps = null;
+  getPowerSyncTables() {
+    return Object.entries(this.config.tables).filter(([_, strategy]) => strategy.strategy === "powersync" || strategy.strategy === "hybrid" || strategy.strategy === "auto").map(([key, strategy]) => getPowerSyncAlias(key, strategy));
+  }
   /**
-   * Whether the registry has been initialized with adapters
+   * Get the PowerSync alias for a table.
+   * Uses explicit alias from config if set, otherwise auto-generates.
+   *
+   * @param table - Table name (may be schema-qualified)
+   * @returns The alias to use in PowerSync schema
    */
-  _isInitialized = false;
+  getTableAlias(table) {
+    const strategy = this.getTableStrategy(table);
+    const tableWithoutSchema = table.includes(".") ? table.split(".")[1] : table;
+    const configKey = this.config.tables[table] ? table : tableWithoutSchema;
+    return getPowerSyncAlias(configKey, strategy);
+  }
+  // ===========================================================================
+  // Auto-Detection Methods
+  // ===========================================================================
   /**
-   * Auto-detector instance for automatic backend selection
+   * Get adapter using auto-detection.
+   *
+   * Simple logic: PowerSync first, Supabase fallback.
+   * Once PowerSync is initialized, always use it for offline-first behavior.
    */
-  autoDetector = null;
+  getAutoAdapter(_strategy, _table) {
+    if (this.powerSyncAdapter) {
+      return this.powerSyncAdapter;
+    }
+    if (this.supabaseAdapter) {
+      return this.supabaseAdapter;
+    }
+    throw new Error("No adapters available. Initialize PowerSync or Supabase.");
+  }
   /**
-   * Sync tracker for mutation tracking
+   * Subscribe to backend changes
+   *
+   * @param callback - Function called when recommended backend changes
+   * @returns Unsubscribe function
    */
-  syncTracker = null;
+  onBackendChange(callback) {
+    this.backendChangeListeners.add(callback);
+    return () => {
+      this.backendChangeListeners.delete(callback);
+    };
+  }
   /**
-   * Sync tracking adapter that wraps PowerSync adapter
+   * Notify listeners of backend change
+   *
+   * @param backend - The new recommended backend
    */
-  syncTrackingAdapter = null;
+  notifyBackendChange(backend) {
+    this.backendChangeListeners.forEach((callback) => {
+      try {
+        callback(backend);
+      } catch (error) {
+        console.error("Error in backend change listener:", error);
+      }
+    });
+  }
   /**
-   * Listeners for backend change events
+   * Get the last auto-detection result
+   *
+   * @returns Last detection result or null if never detected
    */
-  backendChangeListeners = /* @__PURE__ */ new Set();
+  getLastDetectionResult() {
+    return this.lastDetectionResult;
+  }
   /**
-   * Last auto-detection result for debugging and status
+   * Get the auto-detector instance
+   *
+   * @returns Auto-detector instance or null if not initialized
    */
-  lastDetectionResult = null;
+  getAutoDetector() {
+    return this.autoDetector;
+  }
   // ===========================================================================
-  // Initialization
+  // Private Methods
   // ===========================================================================
   /**
-   * Check if the registry has been initialized
-   */
-  get isInitialized() {
-    return this._isInitialized;
-  }
-  /**
-   * Initialize the registry with dependencies.
-   * Called by DataLayerProvider when PowerSync and Supabase are ready.
+   * Create an adapter based on the strategy type
    *
-   * @param deps - Dependencies needed to create adapters
+   * @param strategy - The table strategy configuration
+   * @returns The created adapter
+   * @throws Error if the required base adapter is not initialized
    */
-  initialize(deps) {
-    this.deps = deps;
-    this._isInitialized = true;
+  createAdapter(strategy) {
+    switch (strategy.strategy) {
+      case "powersync":
+        if (!this.powerSyncAdapter) {
+          if (this.supabaseAdapter) {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              console.warn(`[AdapterRegistry] PowerSync not ready, falling back to Supabase`);
+            }
+            return this.supabaseAdapter;
+          }
+          throw new Error("PowerSync adapter not initialized and Supabase not available. Ensure PowerSyncAdapter is set before accessing PowerSync tables.");
+        }
+        return this.syncTrackingAdapter ?? this.powerSyncAdapter;
+      case "supabase":
+        if (!this.supabaseAdapter) {
+          throw new Error("Supabase adapter not initialized. Ensure SupabaseAdapter is set before accessing Supabase tables.");
+        }
+        return this.supabaseAdapter;
+      case "cached":
+        if (this.cachedAdapter) {
+          return this.cachedAdapter;
+        }
+        throw new Error("CachedAdapter not yet implemented. This feature will be available in Wave 2. For now, use 'supabase' strategy as a fallback.");
+      case "hybrid":
+        throw new Error("HybridAdapter not yet implemented. This feature will be available in Wave 2. For now, use 'powersync' or 'supabase' strategy as a fallback.");
+      default:
+        if (!this.supabaseAdapter) {
+          throw new Error("Supabase adapter not initialized. Ensure SupabaseAdapter is set before accessing tables.");
+        }
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.warn(`[AdapterRegistry] Unknown strategy "${strategy.strategy}". Using Supabase fallback.`);
+        }
+        return this.supabaseAdapter;
+    }
   }
+  // ===========================================================================
+  // Utility Methods
+  // ===========================================================================
   /**
-   * Set the PowerSync adapter instance
-   *
-   * @param adapter - PowerSync adapter implementation
+   * Clear all cached adapters.
+   * Useful when configuration changes and adapters need to be recreated.
    */
-  setPowerSyncAdapter(adapter) {
-    this.powerSyncAdapter = adapter;
-    if (this.syncTracker) {
-      this.syncTrackingAdapter = new SyncTrackingAdapter(adapter, this.syncTracker);
-    } else {
-      this.syncTrackingAdapter = null;
-    }
+  clearCache() {
+    this.adapters.clear();
   }
   /**
-   * Set a getter function for lazy PowerSync adapter initialization.
-   *
-   * This allows the registry to lazily create the PowerSync adapter when
-   * PowerSync becomes available, rather than requiring it at initialization time.
-   * Solves race conditions where queries/mutations run before PowerSync is ready.
-   *
-   * @param getter - Function that returns the PowerSync database instance (or null if not ready)
-   * @param factory - Function that creates a TableDataAdapter from the database instance
+   * Reset the registry to uninitialized state.
+   * Used during cleanup or testing.
    */
-  setPowerSyncGetter(getter, factory) {
-    this.powerSyncGetter = getter;
-    this.powerSyncAdapterFactory = factory;
+  reset() {
+    this.adapters.clear();
+    this.powerSyncAdapter = null;
+    this.powerSyncGetter = null;
+    this.powerSyncAdapterFactory = null;
+    this.supabaseAdapter = null;
+    this.cachedAdapter = null;
+    this.deps = null;
+    this._isInitialized = false;
+    this.autoDetector = null;
+    this.backendChangeListeners.clear();
+    this.lastDetectionResult = null;
+    this.syncTracker = null;
+    this.syncTrackingAdapter = null;
   }
   /**
-   * Ensure PowerSync adapter is initialized if available.
-   *
-   * Checks the getter (if set) and lazily creates the adapter if PowerSync
-   * is now available. Also updates the auto-detector with the new reference.
-   *
-   * @returns true if PowerSync adapter is available, false otherwise
+   * Dispose all adapters and clean up resources.
+   * Called when the DataLayerProvider unmounts.
    */
-  ensurePowerSyncAdapter() {
-    if (this.powerSyncAdapter) {
-      return true;
-    }
-    if (!this.powerSyncGetter || !this.powerSyncAdapterFactory) {
-      return false;
-    }
-    const db = this.powerSyncGetter();
-    if (!db) {
-      return false;
-    }
-    const adapter = this.powerSyncAdapterFactory(db);
-    this.setPowerSyncAdapter(adapter);
-    if (this.autoDetector) {
-      this.autoDetector.setPowerSyncDb(db);
-    }
-    return true;
+  dispose() {
+    this.reset();
   }
   /**
-   * Set the sync tracker for mutation tracking.
-   * When set, write operations on PowerSync tables will
-   * automatically track pending mutations.
-   *
-   * NOTE: This also clears the adapter cache to ensure any
-   * previously cached adapters (which may have been created
-   * before the sync tracker was available) are recreated
-   * with the new sync tracker on next access.
+   * Get debug information about the registry state
    */
-  setSyncTracker(tracker) {
-    this.syncTracker = tracker;
-    if (this.powerSyncAdapter) {
-      this.syncTrackingAdapter = new SyncTrackingAdapter(this.powerSyncAdapter, tracker);
-    }
-    this.adapters.clear();
+  getDebugInfo() {
+    return {
+      isInitialized: this._isInitialized,
+      hasPowerSync: this.powerSyncAdapter !== null,
+      hasSupabase: this.supabaseAdapter !== null,
+      hasCached: this.cachedAdapter !== null,
+      cachedAdapterCount: this.adapters.size,
+      configuredTableCount: Object.keys(this.config.tables).length,
+      powerSyncTables: this.getPowerSyncTables(),
+      hasAutoDetector: this.autoDetector !== null,
+      lastDetectionResult: this.lastDetectionResult
+    };
+  }
+};
+function createAdapterRegistry(config) {
+  return new AdapterRegistry(config);
+}
+
+// src/adapters/auto-detector.ts
+var BackendStatus = /* @__PURE__ */ ((BackendStatus2) => {
+  BackendStatus2["AVAILABLE"] = "available";
+  BackendStatus2["INITIALIZING"] = "initializing";
+  BackendStatus2["UNAVAILABLE"] = "unavailable";
+  return BackendStatus2;
+})(BackendStatus || {});
+var AdapterAutoDetector = class {
+  constructor(powerSyncDb, supabase, options = {}) {
+    this.powerSyncDb = powerSyncDb;
+    this.supabase = supabase;
+    this.options = {
+      preferPowerSync: options.preferPowerSync ?? true,
+      statusCheckTimeout: options.statusCheckTimeout ?? 1e3,
+      useOnlineUntilSynced: options.useOnlineUntilSynced ?? true
+    };
   }
+  options;
+  listeners = /* @__PURE__ */ new Set();
+  lastResult = null;
+  syncStatus = null;
   /**
-   * Set the Supabase adapter instance
+   * Update the PowerSync database reference.
+   * Called when PowerSync becomes available after initial construction.
    *
-   * @param adapter - Supabase adapter implementation
+   * @param db - PowerSync database instance or null
    */
-  setSupabaseAdapter(adapter) {
-    this.supabaseAdapter = adapter;
+  setPowerSyncDb(db) {
+    this.powerSyncDb = db;
+    if (db) {
+      this.detect();
+    }
   }
   /**
-   * Set the Cached adapter instance
+   * Update the sync status from PowerSync.
+   * Called when sync status changes to re-evaluate backend recommendation.
    *
-   * @param adapter - Cached adapter implementation
+   * @param status - Current sync status or null if not available
    */
-  setCachedAdapter(adapter) {
-    this.cachedAdapter = adapter;
+  updateSyncStatus(status) {
+    const hadSynced = this.syncStatus?.hasSynced;
+    const hasSyncedNow = status?.hasSynced;
+    const changed = hadSynced !== hasSyncedNow;
+    this.syncStatus = status;
+    if (changed) {
+      this.detect();
+    }
   }
   /**
-   * Initialize auto-detection with a detector instance
-   *
-   * @param detector - The auto-detector to use
+   * Get current sync status.
+   * @returns Current sync status or null
    */
-  initializeAutoDetection(detector) {
-    this.autoDetector = detector;
-    detector.addListener((result) => {
-      this.lastDetectionResult = result;
-      this.notifyBackendChange(result.recommendedBackend);
-    });
+  getSyncStatus() {
+    return this.syncStatus;
   }
   // ===========================================================================
-  // Adapter Access
+  // Main Detection Methods
   // ===========================================================================
   /**
-   * Get the appropriate adapter for a table based on configuration.
-   *
-   * The adapter is selected based on the table's strategy in config.tables:
-   * - "powersync": Returns PowerSyncAdapter
-   * - "supabase": Returns SupabaseAdapter
-   * - "cached": Returns CachedAdapter (wrapping Supabase)
-   * - "hybrid": Returns HybridAdapter (combining PowerSync + Cached)
-   * - "auto": Uses auto-detection to select the best backend
-   *
-   * For tables not in config, defaults to auto-detection if available,
-   * otherwise falls back to SupabaseAdapter.
+   * Detect backend availability and recommend best option.
    *
-   * Supports schema-qualified table names:
-   * - "core.Profile" looks up config["core.Profile"] first, then config["Profile"]
-   * - Auto-generates PowerSync alias as "CoreProfile" if not explicitly set
+   * The detection logic follows this priority:
+   * 1. If preferPowerSync is true and PowerSync is available, use PowerSync
+   * 2. If PowerSync is initializing and online with Supabase available, use Supabase temporarily
+   * 3. If online with Supabase available, use Supabase
+   * 4. If offline but PowerSync available, use PowerSync (offline mode)
+   * 5. If offline and PowerSync exists (even if initializing), use PowerSync local data
+   * 6. Default to Supabase as fallback
    *
-   * @param table - The table name (may be schema-qualified like "core.Profile")
-   * @param operation - The operation type: 'read' uses fallback logic during init, 'write' always uses PowerSync for powersync tables
-   * @returns The appropriate adapter for the table
-   * @throws Error if adapters are not initialized
+   * @returns Detection result with recommendation and reasoning
    */
-  getAdapter(table, _operation = "read") {
-    this.ensurePowerSyncAdapter();
-    const tableWithoutSchema = table.includes(".") ? table.split(".")[1] : table;
-    const strategy = this.config.tables[table] ?? this.config.tables[tableWithoutSchema];
-    if (!strategy || strategy.strategy === "auto") {
-      if (this.powerSyncAdapter) {
-        const powerSyncTableKeys = this.getPowerSyncTableKeys();
-        const isConfigured = powerSyncTableKeys.some((key) => key === table || key === tableWithoutSchema || key.includes(".") && key.split(".")[1] === tableWithoutSchema);
-        if (!isConfigured) {
-          if (this.supabaseAdapter) {
-            return this.supabaseAdapter;
-          }
-          throw new Error(`Table "${table}" is not configured for PowerSync sync and Supabase adapter is not available. Either add this table to the PowerSync schema or initialize the Supabase adapter.`);
-        }
-      }
-      return this.getAutoAdapter(strategy, table);
-    }
-    if (strategy.strategy === "powersync" && this.autoDetector && this.supabaseAdapter) {
-      const detection = this.autoDetector.detectSilent();
-      if (detection.powerSyncStatus === "initializing" /* INITIALIZING */ && detection.isOnline) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.warn(`[AdapterRegistry] Table "${table}" configured for PowerSync but using Supabase. PowerSync status: ${detection.powerSyncStatus}, Online: ${detection.isOnline}`);
-        }
-        return this.supabaseAdapter;
-      }
-    }
-    const existing = this.adapters.get(table);
-    if (existing) {
-      return existing;
+  detect() {
+    const result = this.performDetection();
+    if (this.hasResultChanged(result)) {
+      this.lastResult = result;
+      this.notifyListeners(result);
     }
-    const adapter = this.createAdapter(strategy);
-    this.adapters.set(table, adapter);
-    return adapter;
+    return result;
   }
   /**
-   * Get the PowerSync adapter directly
+   * Detect backend availability WITHOUT notifying listeners.
    *
-   * @returns PowerSync adapter or null if not initialized
+   * This method is safe to call during React's render phase because it does not
+   * trigger state updates in other components. Use this method when you need to
+   * check backend status synchronously during render (e.g., in getAdapter()).
+   *
+   * The regular detect() method with listener notifications should only be called
+   * from useEffect or event handlers to avoid the React warning:
+   * "Cannot update a component while rendering a different component"
+   *
+   * @returns Detection result with recommendation and reasoning
    */
-  getPowerSyncAdapter() {
-    return this.powerSyncAdapter;
+  detectSilent() {
+    const result = this.performDetection();
+    this.lastResult = result;
+    return result;
   }
   /**
-   * Get the Supabase adapter directly
-   *
-   * @returns Supabase adapter or null if not initialized
+   * Internal detection logic shared by detect() and detectSilent().
+   * @private
    */
-  getSupabaseAdapter() {
-    return this.supabaseAdapter;
+  performDetection() {
+    const powerSyncStatus = this.detectPowerSyncStatus();
+    const supabaseStatus = this.detectSupabaseStatus();
+    const isOnline = this.checkOnlineStatus();
+    let recommendedBackend;
+    let reason;
+    if (this.options.preferPowerSync && powerSyncStatus === "available" /* AVAILABLE */) {
+      recommendedBackend = "powersync";
+      reason = "PowerSync is available and preferred for offline-first experience";
+    } else if (powerSyncStatus === "initializing" /* INITIALIZING */ && isOnline && supabaseStatus === "available" /* AVAILABLE */) {
+      recommendedBackend = "supabase";
+      reason = "PowerSync initial sync in progress; using Supabase for fresh data";
+    } else if (supabaseStatus === "available" /* AVAILABLE */ && isOnline) {
+      recommendedBackend = "supabase";
+      reason = "Using Supabase direct connection";
+    } else if (powerSyncStatus === "available" /* AVAILABLE */) {
+      recommendedBackend = "powersync";
+      reason = "Offline mode using PowerSync local data";
+    } else if (!isOnline && this.powerSyncDb) {
+      recommendedBackend = "powersync";
+      reason = "Offline mode - using PowerSync local data (initial sync may be incomplete)";
+    } else {
+      recommendedBackend = "supabase";
+      reason = "No confirmed available backend; defaulting to Supabase";
+    }
+    return {
+      powerSyncStatus,
+      supabaseStatus,
+      recommendedBackend,
+      isOnline,
+      reason
+    };
   }
   /**
-   * Get the Cached adapter directly
+   * Check if PowerSync is available.
    *
-   * @returns Cached adapter or null if not initialized
+   * PowerSync status depends on:
+   * 1. Database instance exists
+   * 2. If useOnlineUntilSynced is true, also checks if initial sync completed
+   *
+   * @returns PowerSync backend status
    */
-  getCachedAdapter() {
-    return this.cachedAdapter;
+  detectPowerSyncStatus() {
+    if (!this.powerSyncDb) {
+      return "unavailable" /* UNAVAILABLE */;
+    }
+    try {
+      if (typeof this.powerSyncDb.getAll !== "function") {
+        return "initializing" /* INITIALIZING */;
+      }
+      if (this.options.useOnlineUntilSynced) {
+        if (!this.syncStatus || !this.syncStatus.hasSynced) {
+          return "initializing" /* INITIALIZING */;
+        }
+      }
+      return "available" /* AVAILABLE */;
+    } catch {
+      return "initializing" /* INITIALIZING */;
+    }
   }
   /**
-   * Get all configured table names
+   * Check if Supabase is available.
    *
-   * @returns Array of table names with explicit strategy configuration
+   * Supabase is considered available if we have a client instance.
+   * The actual network connectivity is checked separately via checkOnlineStatus().
+   *
+   * @returns Supabase backend status
    */
-  getConfiguredTables() {
-    return Object.keys(this.config.tables);
+  detectSupabaseStatus() {
+    if (!this.supabase) {
+      return "unavailable" /* UNAVAILABLE */;
+    }
+    try {
+      if (typeof this.supabase.from === "function") {
+        return "available" /* AVAILABLE */;
+      }
+      return "unavailable" /* UNAVAILABLE */;
+    } catch {
+      return "unavailable" /* UNAVAILABLE */;
+    }
   }
   /**
-   * Get the strategy for a specific table
+   * Check if device is online.
    *
-   * @param table - The table name (may include schema prefix like "core.Profile")
-   * @returns The table strategy or undefined if not configured
+   * Prefers the sync status's isOnline property if available (from React Native NetInfo).
+   * Falls back to navigator.onLine in browser environments.
+   * Returns false by default for non-browser environments (React Native, Node.js, etc.)
+   * to ensure offline-first behavior works correctly.
+   *
+   * @returns Whether the device has network connectivity
    */
-  getTableStrategy(table) {
-    const tableWithoutSchema = table.includes(".") ? table.split(".")[1] : table;
-    return this.config.tables[table] ?? this.config.tables[tableWithoutSchema];
+  checkOnlineStatus() {
+    if (this.syncStatus?.isOnline !== void 0) {
+      return this.syncStatus.isOnline;
+    }
+    if (typeof window !== "undefined" && typeof navigator !== "undefined") {
+      return navigator.onLine;
+    }
+    return false;
   }
+  // ===========================================================================
+  // Instance Management Methods
+  // ===========================================================================
   /**
-   * Check if a table uses PowerSync strategy
+   * Update PowerSync instance (e.g., when it becomes available).
    *
-   * @param table - The table name (may include schema prefix like "core.Profile")
-   * @returns True if table uses PowerSync, Hybrid, or Auto strategy
+   * @param db - New PowerSync database instance or null
    */
-  usesPowerSync(table) {
-    const strategy = this.getTableStrategy(table);
-    return strategy?.strategy === "powersync" || strategy?.strategy === "hybrid" || strategy?.strategy === "auto";
+  setPowerSync(db) {
+    this.powerSyncDb = db;
   }
   /**
-   * Get all table config keys that use PowerSync (may be schema-qualified)
+   * Update Supabase instance.
    *
-   * @returns Array of config keys using PowerSync, Hybrid, or Auto strategy
+   * @param supabase - New Supabase client instance or null
    */
-  getPowerSyncTableKeys() {
-    return Object.entries(this.config.tables).filter(([_, strategy]) => strategy.strategy === "powersync" || strategy.strategy === "hybrid" || strategy.strategy === "auto").map(([key]) => key);
+  setSupabase(supabase) {
+    this.supabase = supabase;
   }
   /**
-   * Get all tables that use PowerSync (returns aliases for PowerSync schema)
+   * Get current PowerSync instance.
    *
-   * @returns Array of PowerSync table aliases
+   * @returns Current PowerSync database instance or null
    */
-  getPowerSyncTables() {
-    return Object.entries(this.config.tables).filter(([_, strategy]) => strategy.strategy === "powersync" || strategy.strategy === "hybrid" || strategy.strategy === "auto").map(([key, strategy]) => getPowerSyncAlias(key, strategy));
+  getPowerSync() {
+    return this.powerSyncDb;
   }
   /**
-   * Get the PowerSync alias for a table.
-   * Uses explicit alias from config if set, otherwise auto-generates.
+   * Get current Supabase instance.
    *
-   * @param table - Table name (may be schema-qualified)
-   * @returns The alias to use in PowerSync schema
+   * @returns Current Supabase client instance or null
    */
-  getTableAlias(table) {
-    const strategy = this.getTableStrategy(table);
-    const tableWithoutSchema = table.includes(".") ? table.split(".")[1] : table;
-    const configKey = this.config.tables[table] ? table : tableWithoutSchema;
-    return getPowerSyncAlias(configKey, strategy);
+  getSupabase() {
+    return this.supabase;
   }
   // ===========================================================================
-  // Auto-Detection Methods
+  // Options Management
   // ===========================================================================
   /**
-   * Get adapter using auto-detection
+   * Update detector options.
    *
-   * @param strategy - Optional auto strategy configuration
-   * @returns The automatically selected adapter
+   * @param options - New options to merge with existing
    */
-  getAutoAdapter(_strategy, table) {
-    if (!this.autoDetector) {
-      if (!this.supabaseAdapter) {
-        throw new Error("No auto-detector configured and Supabase adapter not available. Either initialize auto-detection or set adapters explicitly.");
-      }
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.warn(`[AdapterRegistry] No auto-detector configured${table ? ` for table "${table}"` : ""}. Using Supabase fallback.`);
-      }
-      return this.supabaseAdapter;
-    }
-    const detection = this.autoDetector.detectSilent();
-    this.lastDetectionResult = detection;
-    if (detection.recommendedBackend === "powersync") {
-      if (!this.powerSyncAdapter) {
-        if (!this.supabaseAdapter) {
-          throw new Error("Neither PowerSync nor Supabase adapters are available.");
-        }
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.warn(`[AdapterRegistry] PowerSync recommended${table ? ` for table "${table}"` : ""} but adapter not available. Falling back to Supabase. Reason: ${detection.reason}`);
-        }
-        return this.supabaseAdapter;
-      }
-      return this.powerSyncAdapter;
-    }
-    if (!this.supabaseAdapter) {
-      throw new Error("Supabase adapter not available and PowerSync not recommended.");
-    }
-    return this.supabaseAdapter;
+  setOptions(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
   }
   /**
-   * Subscribe to backend changes
+   * Get current detector options.
    *
-   * @param callback - Function called when recommended backend changes
-   * @returns Unsubscribe function
+   * @returns Current detector options
    */
-  onBackendChange(callback) {
-    this.backendChangeListeners.add(callback);
-    return () => {
-      this.backendChangeListeners.delete(callback);
+  getOptions() {
+    return {
+      ...this.options
     };
   }
+  // ===========================================================================
+  // Listener Management
+  // ===========================================================================
   /**
-   * Notify listeners of backend change
+   * Add a listener for backend change events.
    *
-   * @param backend - The new recommended backend
+   * @param listener - Callback to invoke when detection result changes
+   * @returns Function to remove the listener
    */
-  notifyBackendChange(backend) {
-    this.backendChangeListeners.forEach((callback) => {
-      try {
-        callback(backend);
-      } catch (error) {
-        console.error("Error in backend change listener:", error);
-      }
-    });
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
   }
   /**
-   * Get the last auto-detection result
+   * Remove a listener for backend change events.
    *
-   * @returns Last detection result or null if never detected
+   * @param listener - Listener to remove
    */
-  getLastDetectionResult() {
-    return this.lastDetectionResult;
+  removeListener(listener) {
+    this.listeners.delete(listener);
   }
   /**
-   * Get the auto-detector instance
+   * Get the last detection result.
    *
-   * @returns Auto-detector instance or null if not initialized
+   * @returns Last detection result or null if never detected
    */
-  getAutoDetector() {
-    return this.autoDetector;
+  getLastResult() {
+    return this.lastResult;
   }
   // ===========================================================================
-  // Private Methods
+  // Private Helper Methods
   // ===========================================================================
   /**
-   * Create an adapter based on the strategy type
-   *
-   * @param strategy - The table strategy configuration
-   * @returns The created adapter
-   * @throws Error if the required base adapter is not initialized
+   * Check if the detection result has changed from the last result.
    */
-  createAdapter(strategy) {
-    switch (strategy.strategy) {
-      case "powersync":
-        if (!this.powerSyncAdapter) {
-          if (this.supabaseAdapter) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.warn(`[AdapterRegistry] PowerSync not ready, falling back to Supabase`);
-            }
-            return this.supabaseAdapter;
-          }
-          throw new Error("PowerSync adapter not initialized and Supabase not available. Ensure PowerSyncAdapter is set before accessing PowerSync tables.");
-        }
-        return this.syncTrackingAdapter ?? this.powerSyncAdapter;
-      case "supabase":
-        if (!this.supabaseAdapter) {
-          throw new Error("Supabase adapter not initialized. Ensure SupabaseAdapter is set before accessing Supabase tables.");
-        }
-        return this.supabaseAdapter;
-      case "cached":
-        if (this.cachedAdapter) {
-          return this.cachedAdapter;
-        }
-        throw new Error("CachedAdapter not yet implemented. This feature will be available in Wave 2. For now, use 'supabase' strategy as a fallback.");
-      case "hybrid":
-        throw new Error("HybridAdapter not yet implemented. This feature will be available in Wave 2. For now, use 'powersync' or 'supabase' strategy as a fallback.");
-      default:
-        if (!this.supabaseAdapter) {
-          throw new Error("Supabase adapter not initialized. Ensure SupabaseAdapter is set before accessing tables.");
-        }
-        return this.supabaseAdapter;
+  hasResultChanged(result) {
+    if (!this.lastResult) {
+      return true;
     }
-  }
-  // ===========================================================================
-  // Utility Methods
-  // ===========================================================================
-  /**
-   * Clear all cached adapters.
-   * Useful when configuration changes and adapters need to be recreated.
-   */
-  clearCache() {
-    this.adapters.clear();
-  }
-  /**
-   * Reset the registry to uninitialized state.
-   * Used during cleanup or testing.
-   */
-  reset() {
-    this.adapters.clear();
-    this.powerSyncAdapter = null;
-    this.supabaseAdapter = null;
-    this.cachedAdapter = null;
-    this.deps = null;
-    this._isInitialized = false;
-    this.autoDetector = null;
-    this.backendChangeListeners.clear();
-    this.lastDetectionResult = null;
-    this.syncTracker = null;
-    this.syncTrackingAdapter = null;
-  }
-  /**
-   * Dispose all adapters and clean up resources.
-   * Called when the DataLayerProvider unmounts.
-   */
-  dispose() {
-    this.reset();
+    return this.lastResult.powerSyncStatus !== result.powerSyncStatus || this.lastResult.supabaseStatus !== result.supabaseStatus || this.lastResult.recommendedBackend !== result.recommendedBackend || this.lastResult.isOnline !== result.isOnline;
   }
   /**
-   * Get debug information about the registry state
+   * Notify all listeners of a detection result change.
    */
-  getDebugInfo() {
-    return {
-      isInitialized: this._isInitialized,
-      hasPowerSync: this.powerSyncAdapter !== null,
-      hasSupabase: this.supabaseAdapter !== null,
-      hasCached: this.cachedAdapter !== null,
-      cachedAdapterCount: this.adapters.size,
-      configuredTableCount: Object.keys(this.config.tables).length,
-      powerSyncTables: this.getPowerSyncTables(),
-      hasAutoDetector: this.autoDetector !== null,
-      lastDetectionResult: this.lastDetectionResult
-    };
+  notifyListeners(result) {
+    const isDev = typeof __DEV__ !== "undefined" ? __DEV__ : process.env.NODE_ENV !== "production";
+    if (isDev) {
+      const prevBackend = this.lastResult?.recommendedBackend;
+      if (prevBackend && prevBackend !== result.recommendedBackend) {
+        console.log(`[DataLayer] Backend switched: ${prevBackend} \u2192 ${result.recommendedBackend}`, `| Reason: ${result.reason}`);
+      }
+      if (result.recommendedBackend === "supabase" && this.options.preferPowerSync) {
+        console.log(`[DataLayer] Using online fallback (Supabase)`, `| PowerSync: ${result.powerSyncStatus}`, `| Online: ${result.isOnline}`, `| Reason: ${result.reason}`);
+      }
+    }
+    Array.from(this.listeners).forEach((listener) => {
+      try {
+        listener(result);
+      } catch (error) {
+        console.error("Error in backend change listener:", error);
+      }
+    });
   }
 };
-function createAdapterRegistry(config) {
-  return new AdapterRegistry(config);
+function createAdapterAutoDetector(powerSyncDb, supabase, options) {
+  return new AdapterAutoDetector(powerSyncDb, supabase, options);
 }
 
 // src/adapters/supabase-adapter.ts
@@ -7933,13 +7921,13 @@ export {
   useMutationSuccess,
   useMutationSuccessRN,
   ADAPTER_STRATEGIES,
-  BackendStatus,
-  AdapterAutoDetector,
-  createAdapterAutoDetector,
   SyncTrackingAdapter,
   stripSchemaPrefix,
   AdapterRegistry,
   createAdapterRegistry,
+  BackendStatus,
+  AdapterAutoDetector,
+  createAdapterAutoDetector,
   SupabaseAdapter,
   createSupabaseAdapter,
   getErrorBody,
@@ -7996,4 +7984,4 @@ moment/moment.js:
   (*! license : MIT *)
   (*! momentjs.com *)
 */
-//# sourceMappingURL=chunk-7CLN4ORU.js.map
+//# sourceMappingURL=chunk-EOJGUOJR.js.map