@pol-studios/db 1.0.58 → 1.0.61

package/dist/{chunk-OK2C54B6.js → chunk-7PBTPCRN.js}

@@ -1,18 +1,20 @@
 import {
-  createAdapterAutoDetector,
-  createAdapterRegistry,
+  SyncTrackingAdapter,
   createSupabaseAdapter,
+  getPowerSyncAlias,
   stripSchemaPrefix
-} from "./chunk-LG3OHLGB.js";
+} from "./chunk-FWCHS5NN.js";
 import {
   DataLayerContext,
   DataLayerCoreContext,
   DataLayerNestingContext,
   DataLayerStatusContext
-} from "./chunk-GWYTROSD.js";
+} from "./chunk-L4DFVMTS.js";
 import {
-  QueryExecutor
-} from "./chunk-YRIPM2AN.js";
+  QueryExecutor,
+  transformResultsFromStorage,
+  transformWithRelations
+} from "./chunk-4PZ744G2.js";
 import {
   extractRelationNames,
   parseSelect
@@ -1000,112 +1002,6 @@ var require_es = __commonJS({
   }
 });
 
-// src/utils/type-transformer.ts
-var columnMapCache = /* @__PURE__ */ new WeakMap();
-function getOrCreateSchemaCache(schema) {
-  let cache = columnMapCache.get(schema);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    columnMapCache.set(schema, cache);
-  }
-  return cache;
-}
-function transformValueFromStorage(value, columnInfo) {
-  if (value === null || value === void 0) {
-    return value;
-  }
-  switch (columnInfo.type) {
-    case "boolean":
-      if (typeof value === "number") {
-        return value === 1;
-      }
-      if (typeof value === "string") {
-        return value === "1" || value.toLowerCase() === "true";
-      }
-      return Boolean(value);
-    case "number":
-      if (typeof value === "string") {
-        const num = Number(value);
-        return isNaN(num) ? value : num;
-      }
-      return value;
-    case "date":
-      return value;
-    case "enum":
-    case "string":
-    default:
-      return value;
-  }
-}
-function getColumnInfoMap(schema, tableName) {
-  const cache = getOrCreateSchemaCache(schema);
-  if (cache.has(tableName)) {
-    return cache.get(tableName);
-  }
-  const columnMap = /* @__PURE__ */ new Map();
-  for (const schemaName of Object.keys(schema.schemas)) {
-    const schemaData = schema.schemas[schemaName];
-    const table = schemaData.tables?.[tableName];
-    if (table) {
-      for (const col of table.columns) {
-        columnMap.set(col.name, col);
-      }
-      cache.set(tableName, columnMap);
-      return columnMap;
-    }
-    const view = schemaData.views?.[tableName];
-    if (view) {
-      for (const col of view.columns) {
-        columnMap.set(col.name, col);
-      }
-      cache.set(tableName, columnMap);
-      return columnMap;
-    }
-  }
-  cache.set(tableName, null);
-  return null;
-}
-function transformRowFromStorage(row, schema, tableName) {
-  const columnMap = getColumnInfoMap(schema, tableName);
-  if (!columnMap) {
-    return row;
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(row)) {
-    const columnInfo = columnMap.get(key);
-    if (columnInfo) {
-      result[key] = transformValueFromStorage(value, columnInfo);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function transformResultsFromStorage(rows, schema, tableName) {
-  return rows.map((row) => transformRowFromStorage(row, schema, tableName));
-}
-function transformWithRelations(row, schema, tableName) {
-  const columnMap = getColumnInfoMap(schema, tableName);
-  const result = {};
-  for (const [key, value] of Object.entries(row)) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      result[key] = transformWithRelations(value, schema, key);
-    } else if (Array.isArray(value) && value.length > 0 && typeof value[0] === "object") {
-      result[key] = value.map((item) => transformWithRelations(item, schema, key));
-    } else if (columnMap) {
-      const columnInfo = columnMap.get(key);
-      if (columnInfo) {
-        result[key] = transformValueFromStorage(value, columnInfo);
-      } else {
-        result[key] = value;
-      }
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-
 // src/adapters/powersync-adapter.ts
 import stringify from "fast-json-stable-stringify";
 var DEFAULT_MAX_SUBSCRIPTIONS = 100;
@@ -1120,7 +1016,6 @@ var PowerSyncAdapter = class {
   constructor(db, schema, options) {
     this.db = db;
     this.schema = schema;
-    this.executor = new QueryExecutor(db, schema);
     if (typeof options === "function") {
       this.tableNameResolver = options;
       this.maxSubscriptions = DEFAULT_MAX_SUBSCRIPTIONS;
@@ -1128,6 +1023,7 @@ var PowerSyncAdapter = class {
       this.tableNameResolver = options?.tableNameResolver;
       this.maxSubscriptions = options?.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS;
     }
+    this.executor = new QueryExecutor(db, schema, this.tableNameResolver);
   }
   /**
    * Unique identifier for this adapter type
@@ -1494,12 +1390,13 @@ var PowerSyncAdapter = class {
     return this.schema;
   }
 };
-function createPowerSyncAdapter(db, schema) {
-  return new PowerSyncAdapter(db, schema);
+function createPowerSyncAdapter(db, schema, options) {
+  return new PowerSyncAdapter(db, schema, options);
 }
 
 // src/providers/DataLayerProvider.tsx
-import { useState, useEffect, useLayoutEffect, useMemo, useCallback, useRef, useContext } from "react";
+import { c as _c } from "react/compiler-runtime";
+import { useRef, useEffect, useContext } from "react";
 import { jsx } from "react/jsx-runtime";
 var defaultSyncStatus = {
   isConnected: false,
@@ -1521,289 +1418,346 @@ var defaultSyncControl = {
   setScope: async () => {
     console.warn("Scope control not available: PowerSync not initialized");
   },
-  // Auto-retry controls
-  pauseAutoRetry: () => {
-    console.warn("Pause auto-retry not available: PowerSync not initialized");
-  },
-  resumeAutoRetry: () => {
-    console.warn("Resume auto-retry not available: PowerSync not initialized");
-  },
-  isAutoRetryPaused: false,
-  // Pending mutations
   addPendingMutation: () => {
   },
   removePendingMutation: () => {
   }
 };
-function DataLayerProvider({
-  config,
-  children,
-  powerSyncInstance = null,
-  supabaseClient,
-  queryClient,
-  onInitialized,
-  onError,
-  powerSyncSyncStatus,
-  syncControl: externalSyncControl
-}) {
+function DataLayerProvider(t0) {
+  const $ = _c(70);
+  const {
+    config,
+    children,
+    powerSyncInstance: t1,
+    supabaseClient,
+    queryClient,
+    syncControl: externalSyncControl,
+    powerSyncSyncStatus
+  } = t0;
+  const powerSyncInstance = t1 === void 0 ? null : t1;
+  const hasSynced = powerSyncSyncStatus?.hasSynced ?? (powerSyncInstance ? false : true);
+  const isOnline = powerSyncSyncStatus?.isOnline ?? (typeof navigator !== "undefined" ? navigator.onLine : false);
   const isNested = useContext(DataLayerNestingContext);
   const hasWarnedNesting = useRef(false);
-  if (isNested && !hasWarnedNesting.current && typeof __DEV__ !== "undefined" && __DEV__) {
-    hasWarnedNesting.current = true;
-    console.warn("[DataLayerProvider] Nested DataLayerProvider detected! This usually indicates a setup issue where DataLayerProvider is wrapped twice. Each DataLayerProvider creates its own registry, which can cause:\n  - Queries using wrong adapter (e.g., Supabase instead of PowerSync)\n  - Inconsistent cache state\n  - Unexpected behavior with sync status\n\nCommon causes:\n  - Using both DataLayerWrapper and OfflineDataProvider (OfflineDataProvider already includes DataLayerProvider)\n  - Accidentally wrapping layout twice\n\nFix: Remove the outer DataLayerProvider wrapper.");
+  let t2;
+  let t3;
+  if ($[0] !== isNested) {
+    t2 = () => {
+      if (isNested && !hasWarnedNesting.current && typeof __DEV__ !== "undefined" && __DEV__) {
+        hasWarnedNesting.current = true;
+        console.warn("[DataLayerProvider] Nested DataLayerProvider detected! This usually indicates a setup issue. Remove the outer wrapper.");
+      }
+    };
+    t3 = [isNested];
+    $[0] = isNested;
+    $[1] = t2;
+    $[2] = t3;
+  } else {
+    t2 = $[1];
+    t3 = $[2];
   }
-  const [registry] = useState(() => createAdapterRegistry(config));
-  const powerSyncInstanceRef = useRef(powerSyncInstance);
-  useLayoutEffect(() => {
-    powerSyncInstanceRef.current = powerSyncInstance;
-    registry.setPowerSyncGetter(() => powerSyncInstanceRef.current, (db) => createPowerSyncAdapter(db, config.schema));
-  }, [powerSyncInstance, registry, config.schema]);
-  const resolvedSyncControl = useMemo(() => externalSyncControl ?? defaultSyncControl, [externalSyncControl]);
-  const [isInitializedOnce, setIsInitializedOnce] = useState(false);
-  const [autoDetector, setAutoDetector] = useState(null);
-  const [status, setStatus] = useState({
-    isInitialized: false,
-    currentBackend: null,
-    powerSyncStatus: "unavailable" /* UNAVAILABLE */,
-    isOnline: powerSyncSyncStatus?.isOnline ?? (typeof navigator !== "undefined" ? navigator.onLine : true),
-    lastDetection: null,
-    error: null,
-    hasSynced: powerSyncSyncStatus?.hasSynced ?? false
-  });
-  useEffect(() => {
-    try {
-      const detector = createAdapterAutoDetector(powerSyncInstance, supabaseClient, {
-        preferPowerSync: true,
-        useOnlineUntilSynced: config.initialSync?.useOnlineUntilSynced ?? true
+  useEffect(t2, t3);
+  const syncControl = externalSyncControl ?? defaultSyncControl;
+  let t4;
+  if ($[3] !== config.tables) {
+    t4 = (table) => {
+      const tableWithoutSchema = table.includes(".") ? stripSchemaPrefix(table) : table;
+      return config.tables[table] ?? config.tables[tableWithoutSchema];
+    };
+    $[3] = config.tables;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  const getTableStrategy = t4;
+  let t5;
+  if ($[5] !== config.tables) {
+    t5 = (table_0) => {
+      const tableWithoutSchema_0 = table_0.includes(".") ? stripSchemaPrefix(table_0) : table_0;
+      const strategy = config.tables[table_0] ?? config.tables[tableWithoutSchema_0];
+      const configKey = config.tables[table_0] ? table_0 : tableWithoutSchema_0;
+      return getPowerSyncAlias(configKey, strategy);
+    };
+    $[5] = config.tables;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  const getTableAlias = t5;
+  let t6;
+  if ($[7] !== config.schema || $[8] !== supabaseClient) {
+    t6 = createSupabaseAdapter(supabaseClient, config.schema);
+    $[7] = config.schema;
+    $[8] = supabaseClient;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  const supabaseAdapter = t6;
+  let powerSyncAdapter = null;
+  let syncTrackingAdapter = null;
+  if (powerSyncInstance) {
+    if ($[10] !== config.schema || $[11] !== externalSyncControl || $[12] !== getTableAlias || $[13] !== powerSyncInstance) {
+      powerSyncAdapter = createPowerSyncAdapter(powerSyncInstance, config.schema, {
+        tableNameResolver: getTableAlias
       });
-      setAutoDetector(detector);
-      const supabaseAdapter = createSupabaseAdapter(supabaseClient, config.schema);
-      registry.setSupabaseAdapter(supabaseAdapter);
-      if (powerSyncInstance) {
-        const powerSyncAdapter = createPowerSyncAdapter(powerSyncInstance, config.schema);
-        registry.setPowerSyncAdapter(powerSyncAdapter);
+      if (externalSyncControl?.addPendingMutation) {
+        syncTrackingAdapter = new SyncTrackingAdapter(powerSyncAdapter, {
+          addPendingMutation: externalSyncControl.addPendingMutation,
+          removePendingMutation: externalSyncControl.removePendingMutation
+        });
       }
-      registry.setSyncTracker({
-        addPendingMutation: resolvedSyncControl.addPendingMutation,
-        removePendingMutation: resolvedSyncControl.removePendingMutation
-      });
-      registry.initialize({
-        powerSync: powerSyncInstance,
-        supabase: supabaseClient,
-        queryClient,
-        schema: config.schema
-      });
-      registry.initializeAutoDetection(detector);
-      const detection = detector.detect();
-      setStatus({
-        isInitialized: true,
-        currentBackend: detection.recommendedBackend,
-        powerSyncStatus: detection.powerSyncStatus,
-        isOnline: detection.isOnline,
-        lastDetection: detection,
-        error: null,
-        hasSynced: false
-        // Will be updated by Sync Status Update Effect
-      });
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      setStatus((prev) => ({
-        ...prev,
-        error: err
-      }));
-      onError?.(err);
-    }
-  }, [powerSyncInstance, supabaseClient, queryClient, config.schema, registry, onError]);
-  useEffect(() => {
-    if (powerSyncSyncStatus?.isOnline !== void 0) {
-      return;
+      $[10] = config.schema;
+      $[11] = externalSyncControl;
+      $[12] = getTableAlias;
+      $[13] = powerSyncInstance;
+      $[14] = powerSyncAdapter;
+      $[15] = syncTrackingAdapter;
+    } else {
+      powerSyncAdapter = $[14];
+      syncTrackingAdapter = $[15];
     }
-    const handleOnline = () => {
-      setStatus((prev) => ({
-        ...prev,
-        isOnline: true
-      }));
-      if (autoDetector) {
-        const detection = autoDetector.detect();
-        setStatus((prev) => ({
-          ...prev,
-          currentBackend: detection.recommendedBackend,
-          powerSyncStatus: detection.powerSyncStatus,
-          lastDetection: detection
-        }));
-      }
+  }
+  let t7;
+  if ($[16] !== powerSyncAdapter || $[17] !== supabaseAdapter || $[18] !== syncTrackingAdapter) {
+    t7 = {
+      supabase: supabaseAdapter,
+      powerSync: powerSyncAdapter,
+      syncTracking: syncTrackingAdapter
     };
-    const handleOffline = () => {
-      setStatus((prev) => ({
-        ...prev,
-        isOnline: false
-      }));
-      if (autoDetector) {
-        const detection = autoDetector.detect();
-        setStatus((prev) => ({
-          ...prev,
-          currentBackend: detection.recommendedBackend,
-          powerSyncStatus: detection.powerSyncStatus,
-          lastDetection: detection
-        }));
-      }
+    $[16] = powerSyncAdapter;
+    $[17] = supabaseAdapter;
+    $[18] = syncTrackingAdapter;
+    $[19] = t7;
+  } else {
+    t7 = $[19];
+  }
+  const adapters = t7;
+  let t8;
+  if ($[20] !== getTableStrategy) {
+    t8 = (table_1) => {
+      const strategy_0 = getTableStrategy(table_1);
+      return strategy_0?.strategy === "powersync" || strategy_0?.strategy === "hybrid" || strategy_0?.strategy === "auto" || !strategy_0;
     };
-    const isBrowser = typeof window !== "undefined" && typeof window.addEventListener === "function";
-    if (isBrowser) {
-      window.addEventListener("online", handleOnline);
-      window.addEventListener("offline", handleOffline);
-      return () => {
-        window.removeEventListener("online", handleOnline);
-        window.removeEventListener("offline", handleOffline);
-      };
-    }
-  }, [autoDetector, powerSyncSyncStatus?.isOnline]);
-  useEffect(() => {
-    if (!autoDetector) return;
-    const unsubscribe = autoDetector.addListener((detection) => {
-      setStatus((prev) => ({
-        ...prev,
-        currentBackend: detection.recommendedBackend,
-        powerSyncStatus: detection.powerSyncStatus,
-        isOnline: detection.isOnline,
-        lastDetection: detection
-      }));
-    });
-    return unsubscribe;
-  }, [autoDetector]);
-  useEffect(() => {
-    const currentDetector = registry.getAutoDetector();
-    if (!currentDetector) return;
-    if (powerSyncInstance && currentDetector.getPowerSync() !== powerSyncInstance) {
-      currentDetector.setPowerSyncDb(powerSyncInstance);
-    }
-    currentDetector.updateSyncStatus(powerSyncSyncStatus ?? null);
-    setStatus((prev) => {
-      const newHasSynced = powerSyncSyncStatus?.hasSynced ?? false;
-      const newIsOnline = powerSyncSyncStatus?.isOnline;
-      const hasSyncedChanged = prev.hasSynced !== newHasSynced;
-      const isOnlineChanged = newIsOnline !== void 0 && prev.isOnline !== newIsOnline;
-      if (!hasSyncedChanged && !isOnlineChanged) {
-        return prev;
+    $[20] = getTableStrategy;
+    $[21] = t8;
+  } else {
+    t8 = $[21];
+  }
+  const usesPowerSync = t8;
+  let t9;
+  if ($[22] !== config.tables) {
+    t9 = () => Object.entries(config.tables).filter(_temp).map(_temp2);
+    $[22] = config.tables;
+    $[23] = t9;
+  } else {
+    t9 = $[23];
+  }
+  const getPowerSyncTables = t9;
+  let t10;
+  if ($[24] !== adapters.powerSync || $[25] !== adapters.supabase || $[26] !== adapters.syncTracking || $[27] !== config.tables || $[28] !== hasSynced || $[29] !== isOnline) {
+    t10 = (table_2, t112) => {
+      t112 === void 0 ? "read" : t112;
+      const tableWithoutSchema_1 = table_2.includes(".") ? stripSchemaPrefix(table_2) : table_2;
+      const strategy_3 = config.tables[table_2] ?? config.tables[tableWithoutSchema_1];
+      if (strategy_3?.strategy === "supabase") {
+        return adapters.supabase;
       }
-      return {
-        ...prev,
-        hasSynced: newHasSynced,
-        ...newIsOnline !== void 0 && {
-          isOnline: newIsOnline
+      if (strategy_3?.strategy === "cached") {
+        return adapters.supabase;
+      }
+      if (strategy_3?.strategy === "powersync") {
+        if (adapters.powerSync) {
+          return adapters.syncTracking ?? adapters.powerSync;
         }
-      };
-    });
-  }, [
-    // Note: We use registry.getAutoDetector() instead of autoDetector state
-    // to avoid race conditions. The registry is stable and always has the latest detector.
-    registry,
-    powerSyncInstance,
-    powerSyncSyncStatus?.hasSynced,
-    powerSyncSyncStatus?.connected,
-    powerSyncSyncStatus?.connecting,
-    powerSyncSyncStatus?.isOnline
-  ]);
-  useEffect(() => {
-    if (registry) {
-      registry.setSyncTracker({
-        addPendingMutation: resolvedSyncControl.addPendingMutation,
-        removePendingMutation: resolvedSyncControl.removePendingMutation
-      });
-    }
-  }, [resolvedSyncControl, registry]);
-  useEffect(() => {
-    if (status.isInitialized && !status.error && onInitialized) {
-      const contextValue2 = buildContextValue();
-      if (contextValue2) {
-        onInitialized(contextValue2);
+        return adapters.supabase;
       }
-    }
-  }, [status.isInitialized, status.error]);
-  useEffect(() => {
-    if (status.isInitialized && !isInitializedOnce) {
-      setIsInitializedOnce(true);
-    }
-  }, [status.isInitialized, isInitializedOnce]);
-  const getAdapter = useCallback((table, operation = "read") => {
-    return registry.getAdapter(table, operation);
-  }, [registry]);
-  const buildContextValue = useCallback(() => {
-    if (!status.isInitialized) return null;
-    return {
-      registry,
+      const isAutoTable = !strategy_3 || strategy_3.strategy === "auto" || strategy_3.strategy === "hybrid";
+      if (isAutoTable) {
+        const powerSyncTableKeys = Object.keys(config.tables).filter((key_0) => {
+          const s = config.tables[key_0];
+          return s.strategy === "powersync" || s.strategy === "hybrid" || s.strategy === "auto";
+        });
+        const isConfigured = powerSyncTableKeys.some((key_1) => key_1 === table_2 || key_1 === tableWithoutSchema_1 || key_1.includes(".") && key_1.split(".")[1] === tableWithoutSchema_1);
+        if (!isConfigured) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.warn(`[DataLayerProvider] Table "${table_2}" is not configured for PowerSync. Using Supabase fallback.`);
+          }
+          return adapters.supabase;
+        }
+        if (isOnline && !hasSynced) {
+          return adapters.supabase;
+        }
+        if (adapters.powerSync) {
+          return adapters.syncTracking ?? adapters.powerSync;
+        }
+      }
+      if (!adapters.supabase) {
+        throw new Error(`No adapter available for table "${table_2}". Ensure Supabase client is properly initialized.`);
+      }
+      return adapters.supabase;
+    };
+    $[24] = adapters.powerSync;
+    $[25] = adapters.supabase;
+    $[26] = adapters.syncTracking;
+    $[27] = config.tables;
+    $[28] = hasSynced;
+    $[29] = isOnline;
+    $[30] = t10;
+  } else {
+    t10 = $[30];
+  }
+  const getAdapter = t10;
+  let t11;
+  if ($[31] !== adapters.powerSync || $[32] !== config.tables || $[33] !== getPowerSyncTables) {
+    t11 = () => ({
+      isInitialized: true,
+      hasPowerSync: adapters.powerSync !== null,
+      hasSupabase: true,
+      configuredTableCount: Object.keys(config.tables).length,
+      powerSyncTables: getPowerSyncTables()
+    });
+    $[31] = adapters.powerSync;
+    $[32] = config.tables;
+    $[33] = getPowerSyncTables;
+    $[34] = t11;
+  } else {
+    t11 = $[34];
+  }
+  let t12;
+  if ($[35] !== config || $[36] !== getAdapter || $[37] !== getPowerSyncTables || $[38] !== getTableAlias || $[39] !== getTableStrategy || $[40] !== t11 || $[41] !== usesPowerSync) {
+    t12 = {
       getAdapter,
-      powerSync: powerSyncInstance,
-      supabase: supabaseClient,
-      queryClient,
-      schema: config.schema,
-      status,
-      syncStatus: defaultSyncStatus,
-      syncControl: resolvedSyncControl
+      getTableStrategy,
+      usesPowerSync,
+      getPowerSyncTables,
+      getTableAlias,
+      getDebugInfo: t11,
+      config,
+      isInitialized: true
     };
-  }, [registry, getAdapter, powerSyncInstance, supabaseClient, queryClient, config.schema, status, resolvedSyncControl]);
-  const coreContextValue = useMemo(() => {
-    if (!isInitializedOnce) return null;
-    return {
+    $[35] = config;
+    $[36] = getAdapter;
+    $[37] = getPowerSyncTables;
+    $[38] = getTableAlias;
+    $[39] = getTableStrategy;
+    $[40] = t11;
+    $[41] = usesPowerSync;
+    $[42] = t12;
+  } else {
+    t12 = $[42];
+  }
+  const registry = t12;
+  let t13;
+  if ($[43] !== config.schema || $[44] !== getAdapter || $[45] !== powerSyncInstance || $[46] !== queryClient || $[47] !== registry || $[48] !== supabaseClient || $[49] !== syncControl) {
+    t13 = {
       registry,
       getAdapter,
       powerSync: powerSyncInstance,
       supabase: supabaseClient,
       queryClient,
       schema: config.schema,
-      syncControl: resolvedSyncControl
+      syncControl
     };
-  }, [isInitializedOnce, registry, getAdapter, powerSyncInstance, supabaseClient, queryClient, config.schema, resolvedSyncControl]);
-  const statusContextValue = useMemo(() => {
-    if (!status.isInitialized) return null;
-    return {
+    $[43] = config.schema;
+    $[44] = getAdapter;
+    $[45] = powerSyncInstance;
+    $[46] = queryClient;
+    $[47] = registry;
+    $[48] = supabaseClient;
+    $[49] = syncControl;
+    $[50] = t13;
+  } else {
+    t13 = $[50];
+  }
+  const coreContextValue = t13;
+  const t14 = powerSyncInstance ? "powersync" : "supabase";
+  const t15 = powerSyncInstance ? "available" /* AVAILABLE */ : "unavailable" /* UNAVAILABLE */;
+  let t16;
+  if ($[51] !== hasSynced || $[52] !== isOnline || $[53] !== t14 || $[54] !== t15) {
+    t16 = {
+      isInitialized: true,
+      currentBackend: t14,
+      powerSyncStatus: t15,
+      isOnline,
+      lastDetection: null,
+      error: null,
+      hasSynced
+    };
+    $[51] = hasSynced;
+    $[52] = isOnline;
+    $[53] = t14;
+    $[54] = t15;
+    $[55] = t16;
+  } else {
+    t16 = $[55];
+  }
+  const status = t16;
+  let t17;
+  if ($[56] !== status) {
+    t17 = {
       status,
       syncStatus: defaultSyncStatus
     };
-  }, [status]);
-  const contextValue = useMemo(() => {
-    if (!coreContextValue || !statusContextValue) return null;
-    return {
+    $[56] = status;
+    $[57] = t17;
+  } else {
+    t17 = $[57];
+  }
+  const statusContextValue = t17;
+  let t18;
+  if ($[58] !== coreContextValue || $[59] !== statusContextValue) {
+    t18 = {
       ...coreContextValue,
       ...statusContextValue
     };
-  }, [coreContextValue, statusContextValue]);
-  useEffect(() => {
-    return () => {
-      registry.dispose();
-    };
-  }, [registry]);
-  const pendingCoreContextValue = useMemo(
-    () => ({
-      registry,
-      getAdapter: () => {
-        throw new Error("DataLayer not yet initialized");
-      },
-      powerSync: null,
-      supabase: supabaseClient,
-      queryClient,
-      schema: config.schema,
-      syncControl: resolvedSyncControl
-    }),
-    // Only recompute when these stable deps change — not on every status update
-    [registry, supabaseClient, queryClient, config.schema, resolvedSyncControl]
-  );
-  const pendingStatusContextValue = useMemo(() => ({
-    status,
-    syncStatus: defaultSyncStatus
-  }), [status]);
-  const pendingContextValue = useMemo(() => ({
-    ...pendingCoreContextValue,
-    ...pendingStatusContextValue
-  }), [pendingCoreContextValue, pendingStatusContextValue]);
-  const resolvedCore = coreContextValue ?? pendingCoreContextValue;
-  const resolvedStatus = statusContextValue ?? pendingStatusContextValue;
-  const resolvedContext = contextValue ?? pendingContextValue;
-  return /* @__PURE__ */ jsx(DataLayerNestingContext.Provider, { value: true, children: /* @__PURE__ */ jsx(DataLayerContext.Provider, { value: resolvedContext, children: /* @__PURE__ */ jsx(DataLayerCoreContext.Provider, { value: resolvedCore, children: /* @__PURE__ */ jsx(DataLayerStatusContext.Provider, { value: resolvedStatus, children }) }) }) });
+    $[58] = coreContextValue;
+    $[59] = statusContextValue;
+    $[60] = t18;
+  } else {
+    t18 = $[60];
+  }
+  const contextValue = t18;
+  let t19;
+  if ($[61] !== children || $[62] !== statusContextValue) {
+    t19 = /* @__PURE__ */ jsx(DataLayerStatusContext.Provider, { value: statusContextValue, children });
+    $[61] = children;
+    $[62] = statusContextValue;
+    $[63] = t19;
+  } else {
+    t19 = $[63];
+  }
+  let t20;
+  if ($[64] !== coreContextValue || $[65] !== t19) {
+    t20 = /* @__PURE__ */ jsx(DataLayerCoreContext.Provider, { value: coreContextValue, children: t19 });
+    $[64] = coreContextValue;
+    $[65] = t19;
+    $[66] = t20;
+  } else {
+    t20 = $[66];
+  }
+  let t21;
+  if ($[67] !== contextValue || $[68] !== t20) {
+    t21 = /* @__PURE__ */ jsx(DataLayerNestingContext.Provider, { value: true, children: /* @__PURE__ */ jsx(DataLayerContext.Provider, { value: contextValue, children: t20 }) });
+    $[67] = contextValue;
+    $[68] = t20;
+    $[69] = t21;
+  } else {
+    t21 = $[69];
+  }
+  return t21;
+}
+function _temp2(t0) {
+  const [key, strategy_2] = t0;
+  return getPowerSyncAlias(key, strategy_2);
+}
+function _temp(t0) {
+  const [, strategy_1] = t0;
+  return strategy_1.strategy === "powersync" || strategy_1.strategy === "hybrid" || strategy_1.strategy === "auto";
 }
 
 // src/storage/use-supabase-upload.tsx
-import { useCallback as useCallback3, useEffect as useEffect3, useMemo as useMemo3, useState as useState2 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect3, useMemo as useMemo3, useState } from "react";
 
 // ../../../node_modules/.pnpm/react-dropzone@14.3.8_react@19.2.0/node_modules/react-dropzone/dist/es/index.js
 var import_prop_types = __toESM(require_prop_types(), 1);
@@ -4220,10 +4174,10 @@ var useSupabaseUpload = (options) => {
     cacheControl = 3600,
     upsert = false
   } = options;
-  const [files, setFiles] = useState2([]);
-  const [loading, setLoading] = useState2(false);
-  const [errors, setErrors] = useState2([]);
-  const [successes, setSuccesses] = useState2([]);
+  const [files, setFiles] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [errors, setErrors] = useState([]);
+  const [successes, setSuccesses] = useState([]);
   const isSuccess = useMemo3(() => {
     if (errors.length === 0 && successes.length === 0) {
       return false;
@@ -4327,7 +4281,7 @@ var useSupabaseUpload = (options) => {
 };
 
 // src/conflicts/ConflictContext.tsx
-import { c as _c } from "react/compiler-runtime";
+import { c as _c2 } from "react/compiler-runtime";
 import { createContext, useEffect as useEffect4, useReducer as useReducer2, useRef as useRef3 } from "react";
 
 // src/conflicts/storage.ts
@@ -4479,7 +4433,7 @@ function conflictReducer(state, action) {
   }
 }
 function ConflictProvider(t0) {
-  const $ = _c(29);
+  const $ = _c2(29);
   const {
     children,
     conflictBus
@@ -4513,7 +4467,7 @@ function ConflictProvider(t0) {
             conflicts
           });
         }
-      }).catch(_temp).finally(() => {
+      }).catch(_temp3).finally(() => {
         hasFinishedLoadingRef.current = true;
       });
     };
@@ -4541,7 +4495,7 @@ function ConflictProvider(t0) {
             updatedTimestamps.set(key, now);
           }
         }
-        const currentKeys = new Set(state.pendingConflicts.map(_temp2));
+        const currentKeys = new Set(state.pendingConflicts.map(_temp22));
         for (const key_0 of updatedTimestamps.keys()) {
           if (!currentKeys.has(key_0)) {
             updatedTimestamps.delete(key_0);
@@ -4721,15 +4675,15 @@ function ConflictProvider(t0) {
   }
   return t17;
 }
-function _temp2(c) {
+function _temp22(c) {
   return `${c.table}:${c.recordId}`;
 }
-function _temp(err) {
+function _temp3(err) {
   console.warn("[ConflictProvider] Failed to load conflicts:", err);
 }
 
 // src/conflicts/useConflictState.ts
-import { c as _c2 } from "react/compiler-runtime";
+import { c as _c3 } from "react/compiler-runtime";
 import { useContext as useContext2 } from "react";
 function useConflictState() {
   const context = useContext2(ConflictContext);
@@ -4739,7 +4693,7 @@ function useConflictState() {
   return context;
 }
 function usePendingConflicts() {
-  const $ = _c2(2);
+  const $ = _c3(2);
   const context = useContext2(ConflictContext);
   let t0;
   if ($[0] !== context?.pendingConflicts) {
@@ -4756,7 +4710,7 @@ function useHasConflicts() {
   return context?.hasConflicts ?? false;
 }
 function useConflictForRecord(table, recordId) {
-  const $ = _c2(4);
+  const $ = _c3(4);
   const conflicts = usePendingConflicts();
   let t0;
   if ($[0] !== conflicts || $[1] !== recordId || $[2] !== table) {
@@ -4771,7 +4725,7 @@ function useConflictForRecord(table, recordId) {
   return t0;
 }
 function useConflictsForTable(table) {
-  const $ = _c2(5);
+  const $ = _c3(5);
   const conflicts = usePendingConflicts();
   let t0;
   if ($[0] !== conflicts || $[1] !== table) {
@@ -4793,7 +4747,7 @@ function useConflictsForTable(table) {
   return t0;
 }
 function useConflictCountByTable() {
-  const $ = _c2(2);
+  const $ = _c3(2);
   const conflicts = usePendingConflicts();
   let counts;
   if ($[0] !== conflicts) {
@@ -4810,9 +4764,9 @@ function useConflictCountByTable() {
 }
 
 // src/conflicts/useConflictResolution.ts
-import { c as _c3 } from "react/compiler-runtime";
+import { c as _c4 } from "react/compiler-runtime";
 function useConflictResolution(conflict) {
-  const $ = _c3(28);
+  const $ = _c4(28);
   const {
     resolveConflict
   } = useConflictState();
@@ -4886,7 +4840,7 @@ function useConflictResolution(conflict) {
   const syncFields = t4;
   let t5;
   if ($[13] !== conflict.conflicts) {
-    t5 = new Set(conflict.conflicts.map(_temp3));
+    t5 = new Set(conflict.conflicts.map(_temp4));
     $[13] = conflict.conflicts;
     $[14] = t5;
   } else {
@@ -4948,11 +4902,11 @@ function useConflictResolution(conflict) {
   }
   return t8;
 }
-function _temp3(c) {
+function _temp4(c) {
   return c.field;
 }
 function useBulkConflictResolution() {
-  const $ = _c3(13);
+  const $ = _c4(13);
   const {
     resolveAll,
     resolveConflict,
@@ -5068,4 +5022,4 @@ object-assign/index.js:
   @license MIT
   *)
 */
-//# sourceMappingURL=chunk-OK2C54B6.js.map
+//# sourceMappingURL=chunk-7PBTPCRN.js.map