@pol-studios/db 1.0.10 → 1.0.12

package/dist/{chunk-EL45Z26M.js → chunk-XU3SBFAG.js}

@@ -2,23 +2,25 @@ import {
   createAdapterAutoDetector,
   createAdapterRegistry,
   createSupabaseAdapter
-} from "./chunk-7XT7K4QT.js";
+} from "./chunk-NZON56CB.js";
 import {
   DataLayerContext
-} from "./chunk-3M2U6TXH.js";
+} from "./chunk-ZVBHWU7O.js";
 import {
-  QueryExecutor
-} from "./chunk-ZTSBF536.js";
+  QueryExecutor,
+  extractRelationNames,
+  parseSelect
+} from "./chunk-X3HZLNBV.js";
 import {
   getSupabaseUrl
-} from "./chunk-Y3INY2CS.js";
+} from "./chunk-GC3TBUWE.js";
 import {
   isNullOrWhitespace,
   newUuid
-} from "./chunk-O3K7R32P.js";
+} from "./chunk-OQ7U6EQ3.js";
 import {
   useSupabase
-} from "./chunk-AWFMICFV.js";
+} from "./chunk-5EFDS7SR.js";
 import {
   __commonJS,
   __toESM
@@ -999,7 +1001,139 @@ var require_es = __commonJS({
   }
 });
 
+// ../../../node_modules/.pnpm/is-plain-obj@2.1.0/node_modules/is-plain-obj/index.js
+var require_is_plain_obj = __commonJS({
+  "../../../node_modules/.pnpm/is-plain-obj@2.1.0/node_modules/is-plain-obj/index.js"(exports, module) {
+    "use strict";
+    module.exports = (value) => {
+      if (Object.prototype.toString.call(value) !== "[object Object]") {
+        return false;
+      }
+      const prototype = Object.getPrototypeOf(value);
+      return prototype === null || prototype === Object.prototype;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/merge-options@3.0.4/node_modules/merge-options/index.js
+var require_merge_options = __commonJS({
+  "../../../node_modules/.pnpm/merge-options@3.0.4/node_modules/merge-options/index.js"(exports, module) {
+    "use strict";
+    var isOptionObject = require_is_plain_obj();
+    var { hasOwnProperty } = Object.prototype;
+    var { propertyIsEnumerable } = Object;
+    var defineProperty = (object, name, value) => Object.defineProperty(object, name, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+    var globalThis2 = exports;
+    var defaultMergeOptions = {
+      concatArrays: false,
+      ignoreUndefined: false
+    };
+    var getEnumerableOwnPropertyKeys = (value) => {
+      const keys = [];
+      for (const key in value) {
+        if (hasOwnProperty.call(value, key)) {
+          keys.push(key);
+        }
+      }
+      if (Object.getOwnPropertySymbols) {
+        const symbols = Object.getOwnPropertySymbols(value);
+        for (const symbol of symbols) {
+          if (propertyIsEnumerable.call(value, symbol)) {
+            keys.push(symbol);
+          }
+        }
+      }
+      return keys;
+    };
+    function clone(value) {
+      if (Array.isArray(value)) {
+        return cloneArray(value);
+      }
+      if (isOptionObject(value)) {
+        return cloneOptionObject(value);
+      }
+      return value;
+    }
+    function cloneArray(array) {
+      const result = array.slice(0, 0);
+      getEnumerableOwnPropertyKeys(array).forEach((key) => {
+        defineProperty(result, key, clone(array[key]));
+      });
+      return result;
+    }
+    function cloneOptionObject(object) {
+      const result = Object.getPrototypeOf(object) === null ? /* @__PURE__ */ Object.create(null) : {};
+      getEnumerableOwnPropertyKeys(object).forEach((key) => {
+        defineProperty(result, key, clone(object[key]));
+      });
+      return result;
+    }
+    var mergeKeys = (merged, source, keys, config) => {
+      keys.forEach((key) => {
+        if (typeof source[key] === "undefined" && config.ignoreUndefined) {
+          return;
+        }
+        if (key in merged && merged[key] !== Object.getPrototypeOf(merged)) {
+          defineProperty(merged, key, merge2(merged[key], source[key], config));
+        } else {
+          defineProperty(merged, key, clone(source[key]));
+        }
+      });
+      return merged;
+    };
+    var concatArrays = (merged, source, config) => {
+      let result = merged.slice(0, 0);
+      let resultIndex = 0;
+      [merged, source].forEach((array) => {
+        const indices = [];
+        for (let k = 0; k < array.length; k++) {
+          if (!hasOwnProperty.call(array, k)) {
+            continue;
+          }
+          indices.push(String(k));
+          if (array === merged) {
+            defineProperty(result, resultIndex++, array[k]);
+          } else {
+            defineProperty(result, resultIndex++, clone(array[k]));
+          }
+        }
+        result = mergeKeys(result, array, getEnumerableOwnPropertyKeys(array).filter((key) => !indices.includes(key)), config);
+      });
+      return result;
+    };
+    function merge2(merged, source, config) {
+      if (config.concatArrays && Array.isArray(merged) && Array.isArray(source)) {
+        return concatArrays(merged, source, config);
+      }
+      if (!isOptionObject(source) || !isOptionObject(merged)) {
+        return clone(source);
+      }
+      return mergeKeys(merged, source, getEnumerableOwnPropertyKeys(source), config);
+    }
+    module.exports = function(...options) {
+      const config = merge2(clone(defaultMergeOptions), this !== globalThis2 && this || {}, defaultMergeOptions);
+      let merged = { _: {} };
+      for (const option of options) {
+        if (option === void 0) {
+          continue;
+        }
+        if (!isOptionObject(option)) {
+          throw new TypeError("`" + option + "` is not an Option Object");
+        }
+        merged = merge2(merged, { _: option }, config);
+      }
+      return merged._;
+    };
+  }
+});
+
 // src/useDbUpload.ts
+import { c as _c } from "react/compiler-runtime";
 import { useMutation } from "@tanstack/react-query";
 import { Upload } from "tus-js-client";
 function sanitizeStorageKey(path) {
@@ -1007,7 +1141,11 @@ function sanitizeStorageKey(path) {
   return cleaned.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_.\/]/g, "");
 }
 async function uploadFile(supabase, bucketName, fileName, fileBody, fileOptions, requestOptions) {
-  const { data: { session } } = await supabase.auth.getSession();
+  const {
+    data: {
+      session
+    }
+  } = await supabase.auth.getSession();
   if (session === null) throw new Error("User needs to be logged in.");
   const contentType = "type" in fileBody ? fileBody.type : fileOptions.contentType;
   if (contentType === void 0) {
@@ -1052,42 +1190,60 @@ async function uploadFile(supabase, bucketName, fileName, fileBody, fileOptions,
     });
   });
 }
-function useDbAttachmentUpload(bucketId, options = {
-  onUploadProgress: () => {
+function useDbAttachmentUpload(bucketId, t0) {
+  const $ = _c(6);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {
+      onUploadProgress: _temp
+    } : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
   }
-}) {
+  const options = t1;
   const supabase = useSupabase();
-  const uploadMutation = useMutation({
-    mutationFn: async (item) => {
-      const directory = item.directory ?? newUuid();
-      const originalName = item.fileName ?? ("name" in item.file ? String(item.file["name"]) : "") ?? ("fileName" in item.file ? String(item.file["fileName"]) : "");
-      if (isNullOrWhitespace(originalName)) {
-        throw new Error("file must have a valid name");
-      }
-      const filePath = `${directory}/${sanitizeStorageKey(originalName)}`;
-      await uploadFile(
-        supabase,
-        bucketId,
-        filePath,
-        item.file,
-        {
+  let t2;
+  if ($[2] !== bucketId || $[3] !== options || $[4] !== supabase) {
+    t2 = {
+      mutationFn: async (item) => {
+        const directory = item.directory ?? newUuid();
+        const originalName = item.fileName ?? ("name" in item.file ? String(item.file.name) : "") ?? ("fileName" in item.file ? String(item.file.fileName) : "");
+        if (isNullOrWhitespace(originalName)) {
+          throw new Error("file must have a valid name");
+        }
+        const filePath = `${directory}/${sanitizeStorageKey(originalName)}`;
+        await uploadFile(supabase, bucketId, filePath, item.file, {
           upsert: item.upsert,
           cacheControl: item.cacheControl,
           contentType: item.contentType,
           duplex: item.duplex
-        },
-        { ...options, onUploadProgress: item.onUploadProgress ?? (() => {
-        }) }
-      );
-      return {
-        bucketId,
-        path: filePath,
-        contentType: item.contentType
-      };
-    }
-  });
+        }, {
+          ...options,
+          onUploadProgress: item.onUploadProgress ?? _temp2
+        });
+        return {
+          bucketId,
+          path: filePath,
+          contentType: item.contentType
+        };
+      }
+    };
+    $[2] = bucketId;
+    $[3] = options;
+    $[4] = supabase;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const uploadMutation = useMutation(t2);
   return uploadMutation;
 }
+function _temp2() {
+}
+function _temp() {
+}
 
 // src/utils/type-transformer.ts
 function transformValueFromStorage(value, columnInfo) {
@@ -1162,15 +1318,9 @@ function transformWithRelations(row, 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
-      );
+      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)
-      );
+      result[key] = value.map((item) => transformWithRelations(item, schema, key));
     } else if (columnMap) {
       const columnInfo = columnMap.get(key);
       if (columnInfo) {
@@ -1226,24 +1376,16 @@ var PowerSyncAdapter = class {
    * @returns Promise resolving to query results with optional count
    */
   async query(table, options = {}) {
-    const rawData = await this.executor.execute(
-      table,
-      options
-    );
+    const rawData = await this.executor.execute(table, options);
     const hasRelations = options.select && options.select.includes("(") && options.select !== "*";
-    const data = hasRelations ? rawData.map(
-      (row) => transformWithRelations(
-        row,
-        this.schema,
-        table
-      )
-    ) : transformResultsFromStorage(
-      rawData,
-      this.schema,
-      table
-    );
-    const count = options.limit !== void 0 ? await this.executor.count(table, { where: options.where }) : void 0;
-    return { data, count };
+    const data = hasRelations ? rawData.map((row) => transformWithRelations(row, this.schema, table)) : transformResultsFromStorage(rawData, this.schema, table);
+    const count = options.limit !== void 0 ? await this.executor.count(table, {
+      where: options.where
+    }) : void 0;
+    return {
+      data,
+      count
+    };
   }
   /**
    * Query a single record by ID.
@@ -1254,19 +1396,11 @@ var PowerSyncAdapter = class {
    * @returns Promise resolving to the record or null if not found
    */
   async queryById(table, id, options) {
-    const rawResult = await this.executor.executeById(
-      table,
-      id,
-      options
-    );
+    const rawResult = await this.executor.executeById(table, id, options);
     if (!rawResult) {
       return null;
     }
-    return transformWithRelations(
-      rawResult,
-      this.schema,
-      table
-    );
+    return transformWithRelations(rawResult, this.schema, table);
   }
   /**
    * Subscribe to changes on a query using PowerSync's native watch() API.
@@ -1287,37 +1421,37 @@ var PowerSyncAdapter = class {
     }
     const abortController = new AbortController();
     const builder = this.executor.getBuilder();
-    const { sql, params } = builder.build(table, "*", {
+    const {
+      sql,
+      params
+    } = builder.build(table, "*", {
       where: options.where,
       orderBy: options.orderBy,
       limit: options.limit,
       offset: options.offset
     });
+    let watchTables = [table];
+    if (options.select && options.select !== "*") {
+      const parsed = parseSelect(options.select);
+      const relationNames = extractRelationNames(parsed);
+      watchTables = [table, ...relationNames];
+    }
     const schema = this.schema;
-    this.db.watch(
-      sql,
-      params,
-      {
-        onResult: (results) => {
-          const rawData = results.rows?._array ?? [];
-          const data = transformResultsFromStorage(
-            rawData,
-            schema,
-            table
-          );
-          callback(data);
-        },
-        onError: (error) => {
-          console.error(`PowerSync subscription error for ${table}:`, error);
-        }
+    this.db.watch(sql, params, {
+      onResult: (results) => {
+        const rawData = results.rows?._array ?? [];
+        const data = transformResultsFromStorage(rawData, schema, table);
+        callback(data);
       },
-      {
-        signal: abortController.signal,
-        tables: [table],
-        throttleMs: 100
-        // Throttle to prevent excessive re-queries
+      onError: (error) => {
+        console.error(`PowerSync subscription error for ${table}:`, error);
       }
-    );
+    }, {
+      signal: abortController.signal,
+      tables: watchTables,
+      throttleMs: 100
+      // Throttle to prevent excessive re-queries
+    });
     return () => {
       abortController.abort();
     };
@@ -1332,7 +1466,9 @@ var PowerSyncAdapter = class {
     const poll = async () => {
       if (!isActive) return;
       try {
-        const { data } = await this.query(table, options);
+        const {
+          data
+        } = await this.query(table, options);
         callback(data);
       } catch (error) {
         console.error(`PowerSync subscription error for ${table}:`, error);
@@ -1356,7 +1492,21 @@ var PowerSyncAdapter = class {
    * @returns Promise resolving to the inserted record
    */
   async insert(table, data) {
-    return this.executor.insert(table, data);
+    if (__DEV__) {
+      console.log(`[PowerSyncAdapter] insert called:`, {
+        table,
+        dataKeys: Object.keys(data),
+        hasId: "id" in data
+      });
+    }
+    const result = await this.executor.insert(table, data);
+    if (__DEV__) {
+      console.log(`[PowerSyncAdapter] insert completed:`, {
+        table,
+        resultId: result?.id ?? "unknown"
+      });
+    }
+    return result;
   }
   /**
    * Update an existing record by ID.
@@ -1367,7 +1517,22 @@ var PowerSyncAdapter = class {
    * @returns Promise resolving to the updated record
    */
   async update(table, id, data) {
-    return this.executor.update(table, id, data);
+    if (__DEV__) {
+      console.log(`[PowerSyncAdapter] update called:`, {
+        table,
+        id,
+        dataKeys: Object.keys(data)
+      });
+    }
+    const result = await this.executor.update(table, id, data);
+    if (__DEV__) {
+      console.log(`[PowerSyncAdapter] update completed:`, {
+        table,
+        id,
+        resultId: result?.id ?? "unknown"
+      });
+    }
+    return result;
   }
   /**
    * Upsert (insert or update) a record.
@@ -1379,7 +1544,22 @@ var PowerSyncAdapter = class {
    * @returns Promise resolving to the upserted record
    */
   async upsert(table, data) {
-    return this.executor.upsert(table, data);
+    if (__DEV__) {
+      console.log(`[PowerSyncAdapter] upsert called:`, {
+        table,
+        dataKeys: Object.keys(data),
+        hasId: "id" in data,
+        idValue: data?.id ?? "none"
+      });
+    }
+    const result = await this.executor.upsert(table, data);
+    if (__DEV__) {
+      console.log(`[PowerSyncAdapter] upsert completed:`, {
+        table,
+        resultId: result?.id ?? "unknown"
+      });
+    }
+    return result;
   }
   /**
    * Delete a record by ID.
@@ -1430,12 +1610,7 @@ function createPowerSyncAdapter(db, schema) {
 }
 
 // src/providers/DataLayerProvider.tsx
-import {
-  useState,
-  useEffect,
-  useMemo,
-  useCallback
-} from "react";
+import { useState, useEffect, useMemo, useCallback } from "react";
 import { jsx } from "react/jsx-runtime";
 var defaultSyncStatus = {
   isConnected: false,
@@ -1465,40 +1640,31 @@ function DataLayerProvider({
   supabaseClient,
   queryClient,
   onInitialized,
-  onError
+  onError,
+  powerSyncSyncStatus
 }) {
-  const [registry] = useState(
-    () => createAdapterRegistry(config)
-  );
-  const [autoDetector, setAutoDetector] = useState(
-    null
-  );
+  const [registry] = useState(() => createAdapterRegistry(config));
+  const [autoDetector, setAutoDetector] = useState(null);
   const [status, setStatus] = useState({
     isInitialized: false,
     currentBackend: null,
     powerSyncStatus: "unavailable" /* UNAVAILABLE */,
-    isOnline: typeof navigator !== "undefined" ? navigator.onLine : true,
+    isOnline: powerSyncSyncStatus?.isOnline ?? (typeof navigator !== "undefined" ? navigator.onLine : true),
     lastDetection: null,
-    error: null
+    error: null,
+    hasSynced: powerSyncSyncStatus?.hasSynced ?? false
   });
   useEffect(() => {
     try {
-      const detector = createAdapterAutoDetector(
-        powerSyncInstance,
-        supabaseClient,
-        { preferPowerSync: true }
-      );
+      const detector = createAdapterAutoDetector(powerSyncInstance, supabaseClient, {
+        preferPowerSync: true,
+        useOnlineUntilSynced: config.initialSync?.useOnlineUntilSynced ?? true
+      });
       setAutoDetector(detector);
-      const supabaseAdapter = createSupabaseAdapter(
-        supabaseClient,
-        config.schema
-      );
+      const supabaseAdapter = createSupabaseAdapter(supabaseClient, config.schema);
       registry.setSupabaseAdapter(supabaseAdapter);
       if (powerSyncInstance) {
-        const powerSyncAdapter = createPowerSyncAdapter(
-          powerSyncInstance,
-          config.schema
-        );
+        const powerSyncAdapter = createPowerSyncAdapter(powerSyncInstance, config.schema);
         registry.setPowerSyncAdapter(powerSyncAdapter);
       }
       registry.initialize({
@@ -1507,6 +1673,10 @@ function DataLayerProvider({
         queryClient,
         schema: config.schema
       });
+      registry.initializeAutoDetection(detector);
+      if (powerSyncSyncStatus) {
+        detector.updateSyncStatus(powerSyncSyncStatus);
+      }
       const detection = detector.detect();
       setStatus({
         isInitialized: true,
@@ -1514,7 +1684,8 @@ function DataLayerProvider({
         powerSyncStatus: detection.powerSyncStatus,
         isOnline: detection.isOnline,
         lastDetection: detection,
-        error: null
+        error: null,
+        hasSynced: powerSyncSyncStatus?.hasSynced ?? false
       });
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
@@ -1524,17 +1695,16 @@ function DataLayerProvider({
       }));
       onError?.(err);
     }
-  }, [
-    powerSyncInstance,
-    supabaseClient,
-    queryClient,
-    config.schema,
-    registry,
-    onError
-  ]);
+  }, [powerSyncInstance, supabaseClient, queryClient, config.schema, registry, onError, powerSyncSyncStatus]);
   useEffect(() => {
+    if (powerSyncSyncStatus?.isOnline !== void 0) {
+      return;
+    }
     const handleOnline = () => {
-      setStatus((prev) => ({ ...prev, isOnline: true }));
+      setStatus((prev) => ({
+        ...prev,
+        isOnline: true
+      }));
       if (autoDetector) {
         const detection = autoDetector.detect();
         setStatus((prev) => ({
@@ -1546,7 +1716,10 @@ function DataLayerProvider({
       }
     };
     const handleOffline = () => {
-      setStatus((prev) => ({ ...prev, isOnline: false }));
+      setStatus((prev) => ({
+        ...prev,
+        isOnline: false
+      }));
       if (autoDetector) {
         const detection = autoDetector.detect();
         setStatus((prev) => ({
@@ -1566,7 +1739,7 @@ function DataLayerProvider({
         window.removeEventListener("offline", handleOffline);
       };
     }
-  }, [autoDetector]);
+  }, [autoDetector, powerSyncSyncStatus?.isOnline]);
   useEffect(() => {
     if (!autoDetector) return;
     const unsubscribe = autoDetector.addListener((detection) => {
@@ -1580,6 +1753,18 @@ function DataLayerProvider({
     });
     return unsubscribe;
   }, [autoDetector]);
+  useEffect(() => {
+    if (!autoDetector) return;
+    autoDetector.updateSyncStatus(powerSyncSyncStatus ?? null);
+    setStatus((prev) => ({
+      ...prev,
+      hasSynced: powerSyncSyncStatus?.hasSynced ?? false,
+      // Only update isOnline if powerSyncSyncStatus provides it (React Native via NetInfo)
+      ...powerSyncSyncStatus?.isOnline !== void 0 && {
+        isOnline: powerSyncSyncStatus.isOnline
+      }
+    }));
+  }, [autoDetector, powerSyncSyncStatus?.hasSynced, powerSyncSyncStatus?.connected, powerSyncSyncStatus?.connecting, powerSyncSyncStatus?.isOnline]);
   useEffect(() => {
     if (status.isInitialized && !status.error && onInitialized) {
       const contextValue2 = buildContextValue();
@@ -1588,12 +1773,9 @@ function DataLayerProvider({
       }
     }
   }, [status.isInitialized, status.error]);
-  const getAdapter = useCallback(
-    (table) => {
-      return registry.getAdapter(table);
-    },
-    [registry]
-  );
+  const getAdapter = useCallback((table) => {
+    return registry.getAdapter(table);
+  }, [registry]);
   const buildContextValue = useCallback(() => {
     if (!status.isInitialized) return null;
     return {
@@ -1607,19 +1789,8 @@ function DataLayerProvider({
       syncStatus: defaultSyncStatus,
       syncControl: defaultSyncControl
     };
-  }, [
-    registry,
-    getAdapter,
-    powerSyncInstance,
-    supabaseClient,
-    queryClient,
-    config.schema,
-    status
-  ]);
-  const contextValue = useMemo(
-    () => buildContextValue(),
-    [buildContextValue]
-  );
+  }, [registry, getAdapter, powerSyncInstance, supabaseClient, queryClient, config.schema, status]);
+  const contextValue = useMemo(() => buildContextValue(), [buildContextValue]);
   useEffect(() => {
     return () => {
       registry.dispose();
@@ -4062,30 +4233,30 @@ var useSupabaseUpload = (options) => {
     }
     return false;
   }, [errors.length, successes.length, files.length]);
-  const onDrop = useCallback3(
-    (acceptedFiles, fileRejections) => {
-      const validFiles = acceptedFiles.filter((file) => !files.find((x) => x.name === file.name)).map((file) => {
-        file.preview = URL.createObjectURL(file);
-        file.errors = [];
-        return file;
-      });
-      const invalidFiles = fileRejections.map(({ file, errors: errors2 }) => {
-        file.preview = URL.createObjectURL(file);
-        file.errors = errors2;
-        return file;
-      });
-      const newFiles = [...files, ...validFiles, ...invalidFiles];
-      setFiles(newFiles);
-    },
-    [files, setFiles]
-  );
+  const onDrop = useCallback3((acceptedFiles, fileRejections) => {
+    const validFiles = acceptedFiles.filter((file) => !files.find((x) => x.name === file.name)).map((file_0) => {
+      file_0.preview = URL.createObjectURL(file_0);
+      file_0.errors = [];
+      return file_0;
+    });
+    const invalidFiles = fileRejections.map(({
+      file: file_1,
+      errors: errors_0
+    }) => {
+      file_1.preview = URL.createObjectURL(file_1);
+      file_1.errors = errors_0;
+      return file_1;
+    });
+    const newFiles = [...files, ...validFiles, ...invalidFiles];
+    setFiles(newFiles);
+  }, [files, setFiles]);
   const dropzoneProps = useDropzone({
     onDrop,
     noClick: true,
-    accept: allowedMimeTypes.reduce(
-      (acc, type) => ({ ...acc, [type]: [] }),
-      {}
-    ),
+    accept: allowedMimeTypes.reduce((acc, type) => ({
+      ...acc,
+      [type]: []
+    }), {}),
     maxSize: maxFileSize,
     maxFiles,
     multiple: maxFiles !== 1
@@ -4093,30 +4264,31 @@ var useSupabaseUpload = (options) => {
   const supabase = useSupabase();
   const onUpload = useCallback3(async () => {
     setLoading(true);
-    const filesWithErrors = errors.map((x) => x.name);
-    const filesToUpload = filesWithErrors.length > 0 ? [
-      ...files.filter((f) => filesWithErrors.includes(f.name)),
-      ...files.filter((f) => !successes.includes(f.name))
-    ] : files;
-    const responses = await Promise.all(
-      filesToUpload.map(async (file) => {
-        const { error } = await supabase.storage.from(bucketName).upload(!!path ? `${path}/${file.name}` : file.name, file, {
-          cacheControl: cacheControl.toString(),
-          upsert
-        });
-        if (error) {
-          return { name: file.name, message: error.message };
-        } else {
-          return { name: file.name, message: void 0 };
-        }
-      })
-    );
-    const responseErrors = responses.filter((x) => x.message !== void 0);
+    const filesWithErrors = errors.map((x_0) => x_0.name);
+    const filesToUpload = filesWithErrors.length > 0 ? [...files.filter((f) => filesWithErrors.includes(f.name)), ...files.filter((f_0) => !successes.includes(f_0.name))] : files;
+    const responses = await Promise.all(filesToUpload.map(async (file_2) => {
+      const {
+        error
+      } = await supabase.storage.from(bucketName).upload(!!path ? `${path}/${file_2.name}` : file_2.name, file_2, {
+        cacheControl: cacheControl.toString(),
+        upsert
+      });
+      if (error) {
+        return {
+          name: file_2.name,
+          message: error.message
+        };
+      } else {
+        return {
+          name: file_2.name,
+          message: void 0
+        };
+      }
+    }));
+    const responseErrors = responses.filter((x_1) => x_1.message !== void 0);
     setErrors(responseErrors);
-    const responseSuccesses = responses.filter((x) => x.message === void 0);
-    const newSuccesses = Array.from(
-      /* @__PURE__ */ new Set([...successes, ...responseSuccesses.map((x) => x.name)])
-    );
+    const responseSuccesses = responses.filter((x_2) => x_2.message === void 0);
+    const newSuccesses = Array.from(/* @__PURE__ */ new Set([...successes, ...responseSuccesses.map((x_3) => x_3.name)]));
     setSuccesses(newSuccesses);
     setLoading(false);
   }, [files, path, bucketName, errors, successes]);
@@ -4126,15 +4298,15 @@ var useSupabaseUpload = (options) => {
     }
     if (files.length <= maxFiles) {
       let changed = false;
-      const newFiles = files.map((file) => {
-        if (file.errors.some((e) => e.code === "too-many-files")) {
-          file.errors = file.errors.filter((e) => e.code !== "too-many-files");
+      const newFiles_0 = files.map((file_3) => {
+        if (file_3.errors.some((e_0) => e_0.code === "too-many-files")) {
+          file_3.errors = file_3.errors.filter((e) => e.code !== "too-many-files");
           changed = true;
         }
-        return file;
+        return file_3;
       });
       if (changed) {
-        setFiles(newFiles);
+        setFiles(newFiles_0);
       }
     }
   }, [files.length, setFiles, maxFiles]);
@@ -4154,13 +4326,852 @@ var useSupabaseUpload = (options) => {
   };
 };
 
+// src/conflicts/ConflictContext.tsx
+import { c as _c2 } from "react/compiler-runtime";
+import { createContext, useEffect as useEffect4, useReducer as useReducer2, useRef as useRef2 } from "react";
+
+// ../../../node_modules/.pnpm/merge-options@3.0.4/node_modules/merge-options/index.mjs
+var import_index = __toESM(require_merge_options(), 1);
+var merge_options_default = import_index.default;
+
+// ../../../node_modules/.pnpm/@react-native-async-storage+async-storage@2.2.0_react-native@0.81.5_@babel+core@7.28.0_@react_2hvarrbjesownckmm5rnp7ulv4/node_modules/@react-native-async-storage/async-storage/lib/module/AsyncStorage.js
+var merge = merge_options_default.bind({
+  concatArrays: true,
+  ignoreUndefined: true
+});
+function mergeLocalStorageItem(key, value) {
+  const oldValue = window.localStorage.getItem(key);
+  if (oldValue) {
+    const oldObject = JSON.parse(oldValue);
+    const newObject = JSON.parse(value);
+    const nextValue = JSON.stringify(merge(oldObject, newObject));
+    window.localStorage.setItem(key, nextValue);
+  } else {
+    window.localStorage.setItem(key, value);
+  }
+}
+function createPromise(getValue, callback) {
+  return new Promise((resolve, reject) => {
+    try {
+      const value = getValue();
+      callback?.(null, value);
+      resolve(value);
+    } catch (err) {
+      callback?.(err);
+      reject(err);
+    }
+  });
+}
+function createPromiseAll(promises, callback, processResult) {
+  return Promise.all(promises).then((result) => {
+    const value = processResult?.(result) ?? null;
+    callback?.(null, value);
+    return Promise.resolve(value);
+  }, (errors) => {
+    callback?.(errors);
+    return Promise.reject(errors);
+  });
+}
+var AsyncStorage = {
+  /**
+   * Fetches `key` value.
+   */
+  getItem: (key, callback) => {
+    return createPromise(() => window.localStorage.getItem(key), callback);
+  },
+  /**
+   * Sets `value` for `key`.
+   */
+  setItem: (key, value, callback) => {
+    return createPromise(() => window.localStorage.setItem(key, value), callback);
+  },
+  /**
+   * Removes a `key`
+   */
+  removeItem: (key, callback) => {
+    return createPromise(() => window.localStorage.removeItem(key), callback);
+  },
+  /**
+   * Merges existing value with input value, assuming they are stringified JSON.
+   */
+  mergeItem: (key, value, callback) => {
+    return createPromise(() => mergeLocalStorageItem(key, value), callback);
+  },
+  /**
+   * Erases *all* AsyncStorage for the domain.
+   */
+  clear: (callback) => {
+    return createPromise(() => window.localStorage.clear(), callback);
+  },
+  /**
+   * Gets *all* keys known to the app, for all callers, libraries, etc.
+   */
+  getAllKeys: (callback) => {
+    return createPromise(() => {
+      const numberOfKeys = window.localStorage.length;
+      const keys = [];
+      for (let i = 0; i < numberOfKeys; i += 1) {
+        const key = window.localStorage.key(i) || "";
+        keys.push(key);
+      }
+      return keys;
+    }, callback);
+  },
+  /**
+   * (stub) Flushes any pending requests using a single batch call to get the data.
+   */
+  flushGetRequests: () => void 0,
+  /**
+   * multiGet resolves to an array of key-value pair arrays that matches the
+   * input format of multiSet.
+   *
+   *   multiGet(['k1', 'k2']) -> [['k1', 'val1'], ['k2', 'val2']]
+   */
+  multiGet: (keys, callback) => {
+    const promises = keys.map((key) => AsyncStorage.getItem(key));
+    const processResult = (result) => result.map((value, i) => [keys[i], value]);
+    return createPromiseAll(promises, callback, processResult);
+  },
+  /**
+   * Takes an array of key-value array pairs.
+   *   multiSet([['k1', 'val1'], ['k2', 'val2']])
+   */
+  multiSet: (keyValuePairs, callback) => {
+    const promises = keyValuePairs.map((item) => AsyncStorage.setItem(item[0], item[1]));
+    return createPromiseAll(promises, callback);
+  },
+  /**
+   * Delete all the keys in the `keys` array.
+   */
+  multiRemove: (keys, callback) => {
+    const promises = keys.map((key) => AsyncStorage.removeItem(key));
+    return createPromiseAll(promises, callback);
+  },
+  /**
+   * Takes an array of key-value array pairs and merges them with existing
+   * values, assuming they are stringified JSON.
+   *
+   *   multiMerge([['k1', 'val1'], ['k2', 'val2']])
+   */
+  multiMerge: (keyValuePairs, callback) => {
+    const promises = keyValuePairs.map((item) => AsyncStorage.mergeItem(item[0], item[1]));
+    return createPromiseAll(promises, callback);
+  }
+};
+var AsyncStorage_default = AsyncStorage;
+
+// ../../../node_modules/.pnpm/@react-native-async-storage+async-storage@2.2.0_react-native@0.81.5_@babel+core@7.28.0_@react_2hvarrbjesownckmm5rnp7ulv4/node_modules/@react-native-async-storage/async-storage/lib/module/index.js
+var module_default = AsyncStorage_default;
+
+// src/conflicts/storage.ts
+var CONFLICT_STORAGE_KEY = "@pol/conflicts";
+var TTL_MS = 24 * 60 * 60 * 1e3;
+async function saveConflicts(conflicts, existingTimestamps) {
+  try {
+    const now = Date.now();
+    const persisted = conflicts.map((conflict) => {
+      const key = `${conflict.table}:${conflict.recordId}`;
+      const existingSavedAt = existingTimestamps?.get(key);
+      return {
+        conflict,
+        savedAt: existingSavedAt ?? now
+        // Preserve existing timestamp or use new
+      };
+    });
+    await module_default.setItem(CONFLICT_STORAGE_KEY, JSON.stringify(persisted));
+  } catch (error) {
+    console.warn("[ConflictStorage] Failed to save conflicts:", error);
+  }
+}
+async function loadConflicts() {
+  try {
+    const data = await module_default.getItem(CONFLICT_STORAGE_KEY);
+    if (!data) return {
+      conflicts: [],
+      timestamps: /* @__PURE__ */ new Map()
+    };
+    const persisted = JSON.parse(data);
+    const now = Date.now();
+    const valid = persisted.filter((p) => now - p.savedAt < TTL_MS);
+    if (valid.length !== persisted.length) {
+      await module_default.setItem(CONFLICT_STORAGE_KEY, JSON.stringify(valid));
+    }
+    const timestamps = /* @__PURE__ */ new Map();
+    for (const p of valid) {
+      const key = `${p.conflict.table}:${p.conflict.recordId}`;
+      timestamps.set(key, p.savedAt);
+    }
+    const conflicts = valid.map((p) => ({
+      ...p.conflict,
+      conflicts: p.conflict.conflicts.map((fc) => ({
+        ...fc,
+        changedAt: new Date(fc.changedAt)
+        // Restore Date object from JSON string
+      }))
+    }));
+    return {
+      conflicts,
+      timestamps
+    };
+  } catch (error) {
+    console.warn("[ConflictStorage] Failed to load conflicts:", error);
+    return {
+      conflicts: [],
+      timestamps: /* @__PURE__ */ new Map()
+    };
+  }
+}
+async function clearPersistedConflicts() {
+  try {
+    await module_default.removeItem(CONFLICT_STORAGE_KEY);
+  } catch (error) {
+    console.warn("[ConflictStorage] Failed to clear conflicts:", error);
+  }
+}
+
+// src/conflicts/ConflictContext.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ConflictContext = createContext(null);
+var initialState2 = {
+  pendingConflicts: [],
+  resolutions: /* @__PURE__ */ new Map()
+};
+function conflictKey(table, recordId) {
+  return `${table}:${recordId}`;
+}
+function conflictReducer(state, action) {
+  switch (action.type) {
+    case "ADD_CONFLICT": {
+      const existingIndex = state.pendingConflicts.findIndex((c) => c.recordId === action.conflict.recordId && c.table === action.conflict.table);
+      if (existingIndex >= 0) {
+        const updated = [...state.pendingConflicts];
+        updated[existingIndex] = action.conflict;
+        return {
+          ...state,
+          pendingConflicts: updated
+        };
+      }
+      return {
+        ...state,
+        pendingConflicts: [...state.pendingConflicts, action.conflict]
+      };
+    }
+    case "LOAD_CONFLICTS": {
+      const existingKeys = new Set(state.pendingConflicts.map((c) => conflictKey(c.table, c.recordId)));
+      const newConflicts = action.conflicts.filter((c) => !existingKeys.has(conflictKey(c.table, c.recordId)));
+      return {
+        ...state,
+        pendingConflicts: [...state.pendingConflicts, ...newConflicts]
+      };
+    }
+    case "RESOLVE_CONFLICT": {
+      const key = conflictKey(action.table, action.recordId);
+      const newResolutions = new Map(state.resolutions);
+      newResolutions.set(key, action.resolution);
+      return {
+        ...state,
+        // Remove the resolved conflict from pending
+        pendingConflicts: state.pendingConflicts.filter((c) => conflictKey(c.table, c.recordId) !== key),
+        resolutions: newResolutions
+      };
+    }
+    case "RESOLVE_ALL": {
+      const newResolutions = new Map(state.resolutions);
+      for (const conflict of state.pendingConflicts) {
+        const key = conflictKey(conflict.table, conflict.recordId);
+        newResolutions.set(key, action.resolution);
+      }
+      return {
+        pendingConflicts: [],
+        resolutions: newResolutions
+      };
+    }
+    case "REMOVE_CONFLICT": {
+      const key = conflictKey(action.table, action.recordId);
+      return {
+        ...state,
+        pendingConflicts: state.pendingConflicts.filter((c) => conflictKey(c.table, c.recordId) !== key),
+        resolutions: (() => {
+          const newResolutions = new Map(state.resolutions);
+          newResolutions.delete(key);
+          return newResolutions;
+        })()
+      };
+    }
+    case "CLEAR_RESOLVED": {
+      return {
+        ...state,
+        resolutions: /* @__PURE__ */ new Map()
+      };
+    }
+    case "CLEAR_ALL":
+      return initialState2;
+    default:
+      return state;
+  }
+}
+function ConflictProvider(t0) {
+  const $ = _c2(29);
+  const {
+    children,
+    conflictBus
+  } = t0;
+  const [state, dispatch] = useReducer2(conflictReducer, initialState2);
+  const hasFinishedLoadingRef = useRef2(false);
+  let t1;
+  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t1 = /* @__PURE__ */ new Map();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const savedAtTimestampsRef = useRef2(t1);
+  let t2;
+  let t3;
+  if ($[1] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t2 = () => {
+      if (hasFinishedLoadingRef.current) {
+        return;
+      }
+      loadConflicts().then((t42) => {
+        const {
+          conflicts,
+          timestamps
+        } = t42;
+        savedAtTimestampsRef.current = timestamps;
+        if (conflicts.length > 0) {
+          dispatch({
+            type: "LOAD_CONFLICTS",
+            conflicts
+          });
+        }
+      }).catch(_temp3).finally(() => {
+        hasFinishedLoadingRef.current = true;
+      });
+    };
+    t3 = [];
+    $[1] = t2;
+    $[2] = t3;
+  } else {
+    t2 = $[1];
+    t3 = $[2];
+  }
+  useEffect4(t2, t3);
+  let t4;
+  let t5;
+  if ($[3] !== state.pendingConflicts) {
+    t4 = () => {
+      if (!hasFinishedLoadingRef.current) {
+        return;
+      }
+      if (state.pendingConflicts.length > 0) {
+        const now = Date.now();
+        const updatedTimestamps = new Map(savedAtTimestampsRef.current);
+        for (const conflict of state.pendingConflicts) {
+          const key = `${conflict.table}:${conflict.recordId}`;
+          if (!updatedTimestamps.has(key)) {
+            updatedTimestamps.set(key, now);
+          }
+        }
+        const currentKeys = new Set(state.pendingConflicts.map(_temp22));
+        for (const key_0 of updatedTimestamps.keys()) {
+          if (!currentKeys.has(key_0)) {
+            updatedTimestamps.delete(key_0);
+          }
+        }
+        savedAtTimestampsRef.current = updatedTimestamps;
+        saveConflicts(state.pendingConflicts, updatedTimestamps);
+      } else {
+        savedAtTimestampsRef.current = /* @__PURE__ */ new Map();
+        clearPersistedConflicts();
+      }
+    };
+    t5 = [state.pendingConflicts];
+    $[3] = state.pendingConflicts;
+    $[4] = t4;
+    $[5] = t5;
+  } else {
+    t4 = $[4];
+    t5 = $[5];
+  }
+  useEffect4(t4, t5);
+  let t6;
+  if ($[6] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t6 = (conflict_0) => {
+      dispatch({
+        type: "ADD_CONFLICT",
+        conflict: conflict_0
+      });
+    };
+    $[6] = t6;
+  } else {
+    t6 = $[6];
+  }
+  const addConflict = t6;
+  let t7;
+  let t8;
+  if ($[7] !== conflictBus) {
+    t7 = () => {
+      if (!conflictBus) {
+        return;
+      }
+      const unsubscribeConflict = conflictBus.onConflict((conflict_1) => {
+        dispatch({
+          type: "ADD_CONFLICT",
+          conflict: conflict_1
+        });
+      });
+      return () => {
+        unsubscribeConflict();
+      };
+    };
+    t8 = [conflictBus];
+    $[7] = conflictBus;
+    $[8] = t7;
+    $[9] = t8;
+  } else {
+    t7 = $[8];
+    t8 = $[9];
+  }
+  useEffect4(t7, t8);
+  let t9;
+  if ($[10] !== conflictBus) {
+    t9 = (table, recordId, resolution) => {
+      dispatch({
+        type: "RESOLVE_CONFLICT",
+        table,
+        recordId,
+        resolution
+      });
+      conflictBus?.emitResolution(table, recordId, resolution);
+    };
+    $[10] = conflictBus;
+    $[11] = t9;
+  } else {
+    t9 = $[11];
+  }
+  const resolveConflict = t9;
+  let t10;
+  if ($[12] !== conflictBus || $[13] !== state.pendingConflicts) {
+    t10 = (resolution_0) => {
+      const conflictsToResolve = [...state.pendingConflicts];
+      dispatch({
+        type: "RESOLVE_ALL",
+        resolution: resolution_0
+      });
+      for (const conflict_2 of conflictsToResolve) {
+        conflictBus?.emitResolution(conflict_2.table, conflict_2.recordId, resolution_0);
+      }
+    };
+    $[12] = conflictBus;
+    $[13] = state.pendingConflicts;
+    $[14] = t10;
+  } else {
+    t10 = $[14];
+  }
+  const resolveAll = t10;
+  let t11;
+  if ($[15] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t11 = (table_0, recordId_0) => {
+      dispatch({
+        type: "REMOVE_CONFLICT",
+        table: table_0,
+        recordId: recordId_0
+      });
+    };
+    $[15] = t11;
+  } else {
+    t11 = $[15];
+  }
+  const removeConflict = t11;
+  let t12;
+  if ($[16] !== state.resolutions) {
+    t12 = (table_1, recordId_1) => state.resolutions.get(conflictKey(table_1, recordId_1));
+    $[16] = state.resolutions;
+    $[17] = t12;
+  } else {
+    t12 = $[17];
+  }
+  const getResolution = t12;
+  let t13;
+  if ($[18] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t13 = () => {
+      dispatch({
+        type: "CLEAR_RESOLVED"
+      });
+    };
+    $[18] = t13;
+  } else {
+    t13 = $[18];
+  }
+  const clearResolved = t13;
+  let t14;
+  if ($[19] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t14 = () => {
+      dispatch({
+        type: "CLEAR_ALL"
+      });
+      clearPersistedConflicts();
+    };
+    $[19] = t14;
+  } else {
+    t14 = $[19];
+  }
+  const clearAll = t14;
+  const t15 = state.pendingConflicts.length > 0;
+  let t16;
+  if ($[20] !== getResolution || $[21] !== resolveAll || $[22] !== resolveConflict || $[23] !== state.pendingConflicts || $[24] !== t15) {
+    t16 = {
+      pendingConflicts: state.pendingConflicts,
+      addConflict,
+      resolveConflict,
+      resolveAll,
+      removeConflict,
+      getResolution,
+      clearResolved,
+      clearAll,
+      hasConflicts: t15
+    };
+    $[20] = getResolution;
+    $[21] = resolveAll;
+    $[22] = resolveConflict;
+    $[23] = state.pendingConflicts;
+    $[24] = t15;
+    $[25] = t16;
+  } else {
+    t16 = $[25];
+  }
+  const value = t16;
+  let t17;
+  if ($[26] !== children || $[27] !== value) {
+    t17 = /* @__PURE__ */ jsx2(ConflictContext.Provider, { value, children });
+    $[26] = children;
+    $[27] = value;
+    $[28] = t17;
+  } else {
+    t17 = $[28];
+  }
+  return t17;
+}
+function _temp22(c) {
+  return `${c.table}:${c.recordId}`;
+}
+function _temp3(err) {
+  console.warn("[ConflictProvider] Failed to load conflicts:", err);
+}
+
+// src/conflicts/useConflictState.ts
+import { c as _c3 } from "react/compiler-runtime";
+import { useContext } from "react";
+function useConflictState() {
+  const context = useContext(ConflictContext);
+  if (!context) {
+    throw new Error("useConflictState must be used within a ConflictProvider. Wrap your app with <ConflictProvider> to enable conflict management.");
+  }
+  return context;
+}
+function usePendingConflicts() {
+  const $ = _c3(2);
+  const context = useContext(ConflictContext);
+  let t0;
+  if ($[0] !== context?.pendingConflicts) {
+    t0 = context?.pendingConflicts ?? [];
+    $[0] = context?.pendingConflicts;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+function useHasConflicts() {
+  const context = useContext(ConflictContext);
+  return context?.hasConflicts ?? false;
+}
+function useConflictForRecord(table, recordId) {
+  const $ = _c3(4);
+  const conflicts = usePendingConflicts();
+  let t0;
+  if ($[0] !== conflicts || $[1] !== recordId || $[2] !== table) {
+    t0 = conflicts.find((c) => c.table === table && c.recordId === recordId) ?? null;
+    $[0] = conflicts;
+    $[1] = recordId;
+    $[2] = table;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  return t0;
+}
+function useConflictsForTable(table) {
+  const $ = _c3(5);
+  const conflicts = usePendingConflicts();
+  let t0;
+  if ($[0] !== conflicts || $[1] !== table) {
+    let t1;
+    if ($[3] !== table) {
+      t1 = (c) => c.table === table;
+      $[3] = table;
+      $[4] = t1;
+    } else {
+      t1 = $[4];
+    }
+    t0 = conflicts.filter(t1);
+    $[0] = conflicts;
+    $[1] = table;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+function useConflictCountByTable() {
+  const $ = _c3(2);
+  const conflicts = usePendingConflicts();
+  let counts;
+  if ($[0] !== conflicts) {
+    counts = /* @__PURE__ */ new Map();
+    for (const conflict of conflicts) {
+      counts.set(conflict.table, (counts.get(conflict.table) ?? 0) + 1);
+    }
+    $[0] = conflicts;
+    $[1] = counts;
+  } else {
+    counts = $[1];
+  }
+  return counts;
+}
+
+// src/conflicts/useConflictResolution.ts
+import { c as _c4 } from "react/compiler-runtime";
+function useConflictResolution(conflict) {
+  const $ = _c4(28);
+  const {
+    resolveConflict
+  } = useConflictState();
+  let t0;
+  if ($[0] !== conflict.recordId || $[1] !== conflict.table || $[2] !== resolveConflict) {
+    t0 = (resolution) => {
+      resolveConflict(conflict.table, conflict.recordId, resolution);
+    };
+    $[0] = conflict.recordId;
+    $[1] = conflict.table;
+    $[2] = resolveConflict;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  const resolve = t0;
+  let t1;
+  if ($[4] !== resolve) {
+    t1 = () => {
+      resolve({
+        action: "keep-server"
+      });
+    };
+    $[4] = resolve;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const keepServer = t1;
+  let t2;
+  if ($[6] !== resolve) {
+    t2 = () => {
+      resolve({
+        action: "overwrite"
+      });
+    };
+    $[6] = resolve;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  const overwrite = t2;
+  let t3;
+  if ($[8] !== conflict.nonConflictingChanges || $[9] !== resolve) {
+    t3 = () => {
+      resolve({
+        action: "partial",
+        fields: conflict.nonConflictingChanges
+      });
+    };
+    $[8] = conflict.nonConflictingChanges;
+    $[9] = resolve;
+    $[10] = t3;
+  } else {
+    t3 = $[10];
+  }
+  const syncNonConflicting = t3;
+  let t4;
+  if ($[11] !== resolve) {
+    t4 = (fields) => {
+      resolve({
+        action: "partial",
+        fields
+      });
+    };
+    $[11] = resolve;
+    $[12] = t4;
+  } else {
+    t4 = $[12];
+  }
+  const syncFields = t4;
+  let t5;
+  if ($[13] !== conflict.conflicts) {
+    t5 = new Set(conflict.conflicts.map(_temp4));
+    $[13] = conflict.conflicts;
+    $[14] = t5;
+  } else {
+    t5 = $[14];
+  }
+  const conflictFieldSet = t5;
+  let t6;
+  if ($[15] !== conflictFieldSet) {
+    t6 = (field) => conflictFieldSet.has(field);
+    $[15] = conflictFieldSet;
+    $[16] = t6;
+  } else {
+    t6 = $[16];
+  }
+  const hasFieldConflict = t6;
+  let t7;
+  if ($[17] !== conflict.conflicts) {
+    t7 = (field_0) => {
+      const fc = conflict.conflicts.find((c_0) => c_0.field === field_0);
+      if (!fc) {
+        return null;
+      }
+      return {
+        localValue: fc.localValue,
+        serverValue: fc.serverValue,
+        changedBy: fc.changedBy,
+        changedAt: fc.changedAt
+      };
+    };
+    $[17] = conflict.conflicts;
+    $[18] = t7;
+  } else {
+    t7 = $[18];
+  }
+  const getFieldConflict = t7;
+  let t8;
+  if ($[19] !== conflict || $[20] !== getFieldConflict || $[21] !== hasFieldConflict || $[22] !== keepServer || $[23] !== overwrite || $[24] !== resolve || $[25] !== syncFields || $[26] !== syncNonConflicting) {
+    t8 = {
+      conflict,
+      resolve,
+      keepServer,
+      overwrite,
+      syncNonConflicting,
+      syncFields,
+      hasFieldConflict,
+      getFieldConflict
+    };
+    $[19] = conflict;
+    $[20] = getFieldConflict;
+    $[21] = hasFieldConflict;
+    $[22] = keepServer;
+    $[23] = overwrite;
+    $[24] = resolve;
+    $[25] = syncFields;
+    $[26] = syncNonConflicting;
+    $[27] = t8;
+  } else {
+    t8 = $[27];
+  }
+  return t8;
+}
+function _temp4(c) {
+  return c.field;
+}
+function useBulkConflictResolution() {
+  const $ = _c4(13);
+  const {
+    resolveAll,
+    resolveConflict,
+    pendingConflicts,
+    clearResolved
+  } = useConflictState();
+  let t0;
+  if ($[0] !== resolveAll) {
+    t0 = () => {
+      resolveAll({
+        action: "keep-server"
+      });
+    };
+    $[0] = resolveAll;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const resolveAllKeepServer = t0;
+  let t1;
+  if ($[2] !== resolveAll) {
+    t1 = () => {
+      resolveAll({
+        action: "overwrite"
+      });
+    };
+    $[2] = resolveAll;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const resolveAllOverwrite = t1;
+  let t2;
+  if ($[4] !== pendingConflicts || $[5] !== resolveConflict) {
+    t2 = () => {
+      for (const conflict of pendingConflicts) {
+        resolveConflict(conflict.table, conflict.recordId, {
+          action: "partial",
+          fields: conflict.nonConflictingChanges
+        });
+      }
+    };
+    $[4] = pendingConflicts;
+    $[5] = resolveConflict;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  const resolveAllSyncNonConflicting = t2;
+  let t3;
+  if ($[7] !== clearResolved || $[8] !== pendingConflicts.length || $[9] !== resolveAllKeepServer || $[10] !== resolveAllOverwrite || $[11] !== resolveAllSyncNonConflicting) {
+    t3 = {
+      resolveAllKeepServer,
+      resolveAllOverwrite,
+      resolveAllSyncNonConflicting,
+      clearResolved,
+      conflictCount: pendingConflicts.length
+    };
+    $[7] = clearResolved;
+    $[8] = pendingConflicts.length;
+    $[9] = resolveAllKeepServer;
+    $[10] = resolveAllOverwrite;
+    $[11] = resolveAllSyncNonConflicting;
+    $[12] = t3;
+  } else {
+    t3 = $[12];
+  }
+  return t3;
+}
+
 export {
   sanitizeStorageKey,
   useDbAttachmentUpload,
   PowerSyncAdapter,
   createPowerSyncAdapter,
   DataLayerProvider,
-  useSupabaseUpload
+  useSupabaseUpload,
+  ConflictContext,
+  ConflictProvider,
+  useConflictState,
+  usePendingConflicts,
+  useHasConflicts,
+  useConflictForRecord,
+  useConflictsForTable,
+  useConflictCountByTable,
+  useConflictResolution,
+  useBulkConflictResolution
 };
 /*! Bundled license information:
 
@@ -4191,4 +5202,4 @@ object-assign/index.js:
   @license MIT
   *)
 */
-//# sourceMappingURL=chunk-EL45Z26M.js.map
+//# sourceMappingURL=chunk-XU3SBFAG.js.map