@pol-studios/db 1.0.9 → 1.0.11

package/dist/chunk-NZON56CB.js

@@ -0,0 +1,3864 @@
+import {
+  normalizeFilter,
+  useDbAdvanceFilterQuery
+} from "./chunk-H3LNH2NT.js";
+import {
+  OperationLog
+} from "./chunk-7SCJNYTE.js";
+import {
+  useDbQuery
+} from "./chunk-WGDJ4IXR.js";
+import {
+  useDbUpsert
+} from "./chunk-ZVBHWU7O.js";
+import {
+  getSupabaseUrl
+} from "./chunk-GC3TBUWE.js";
+import {
+  PostgrestParser
+} from "./chunk-TKWR5AAY.js";
+import {
+  chunkArray,
+  diff,
+  getObjectChanges,
+  isNullOrWhitespace,
+  isUsable,
+  newUuid,
+  omit,
+  require_moment
+} from "./chunk-OQ7U6EQ3.js";
+import {
+  buildNormalizedQuery,
+  encode,
+  normalizeResponse,
+  useDeleteItem,
+  useDeleteManyMutation,
+  useInsertMutation,
+  useQueriesForTableLoader,
+  useQuery,
+  useUpsertItem
+} from "./chunk-H6365JPC.js";
+import {
+  UserSessionId,
+  useSupabase
+} from "./chunk-5EFDS7SR.js";
+import {
+  __require,
+  __toESM
+} from "./chunk-P4UZ7IXC.js";
+
+// src/useDbDelete.ts
+import { c as _c } from "react/compiler-runtime";
+import { useMutation } from "@tanstack/react-query";
+function useDbDelete(relation, t0) {
+  const $ = _c(14);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? ["id"] : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const primaryKeys = t1;
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? relation.schema : "public";
+  const supabase = useSupabase();
+  let t2;
+  if ($[2] !== primaryKeys) {
+    t2 = primaryKeys.map(_temp);
+    $[2] = primaryKeys;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const t3 = t2;
+  let t4;
+  if ($[4] !== schemaName || $[5] !== t3 || $[6] !== tableName) {
+    t4 = {
+      primaryKeys: t3,
+      table: tableName,
+      schema: schemaName
+    };
+    $[4] = schemaName;
+    $[5] = t3;
+    $[6] = tableName;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  const deleteItem = useDeleteItem(t4);
+  let t5;
+  if ($[8] !== deleteItem || $[9] !== primaryKeys || $[10] !== schemaName || $[11] !== supabase || $[12] !== tableName) {
+    t5 = {
+      mutationFn: async (item) => {
+        if (Array.isArray(item)) {
+          throw new Error("Item cannot be an array.");
+        }
+        const deleteQuery = supabase.schema(schemaName).from(tableName).delete();
+        primaryKeys.forEach((key) => {
+          const keyStr = String(key);
+          const value = item[keyStr];
+          if (isUsable(value)) {
+            deleteQuery.eq(keyStr, value);
+          }
+        });
+        const response = await deleteQuery.select().single();
+        if (response.error) {
+          throw response.error;
+        }
+        if (response.data) {
+          deleteItem(response.data);
+        } else {
+          deleteItem(item);
+        }
+        return response.data;
+      }
+    };
+    $[8] = deleteItem;
+    $[9] = primaryKeys;
+    $[10] = schemaName;
+    $[11] = supabase;
+    $[12] = tableName;
+    $[13] = t5;
+  } else {
+    t5 = $[13];
+  }
+  const deleteMutation = useMutation(t5);
+  return deleteMutation;
+}
+function _temp(k) {
+  return String(k);
+}
+
+// src/useDbInfiniteQuery.ts
+import { useInfiniteQuery } from "@tanstack/react-query";
+import { useMemo, useRef } from "react";
+function useDbInfiniteQuery(query, countPerLoad, config) {
+  const initialQueryKey = encode(query, false).join("-");
+  const lastKnownQuery = useRef(initialQueryKey);
+  const currentPageNumber = useRef(1);
+  if (lastKnownQuery.current != initialQueryKey) {
+    lastKnownQuery.current = initialQueryKey;
+    currentPageNumber.current = 1;
+  }
+  const isFetching = useRef(false);
+  const queryKey = useMemo(() => encode(query, false), [initialQueryKey, config?.crossOrganization]);
+  const getQuery = useInfiniteQuery({
+    ...config,
+    queryKey,
+    queryFn: async ({
+      pageParam,
+      signal
+    }) => {
+      let adjustableQuery = query;
+      const pageNumber = pageParam;
+      if (config?.onQuery && config?.enableOnQuery) {
+        config?.onQuery({
+          query: adjustableQuery,
+          pageParam: pageNumber
+        });
+      } else {
+        adjustableQuery = adjustableQuery.range((pageNumber - 1) * countPerLoad, pageNumber * countPerLoad - 1);
+      }
+      adjustableQuery = adjustableQuery.abortSignal(signal);
+      updatedCache.current = false;
+      const response = await adjustableQuery;
+      currentPageNumber.current = pageNumber;
+      if (response.error) {
+        throw response.error;
+      } else {
+        return response;
+      }
+    },
+    initialPageParam: 1,
+    getNextPageParam: (response_0, allResponses, lastParam) => {
+      const pageParam_0 = lastParam;
+      const resp = response_0;
+      if (allResponses.length * countPerLoad >= (resp?.count ?? 0)) {
+        return void 0;
+      }
+      return pageParam_0 + 1;
+    }
+  });
+  const updatedCache = useRef(true);
+  return useMemo(() => {
+    const pages = getQuery.data?.pages;
+    return {
+      ...getQuery,
+      count: pages?.[pages.length - 1]?.count,
+      data: pages?.flatMap((x) => x.data ?? [])
+    };
+  }, [getQuery.data, currentPageNumber.current]);
+}
+
+// src/useDbInsert.ts
+import { c as _c2 } from "react/compiler-runtime";
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+function useDbInsert(relation, t0, query, mutationOption) {
+  const $ = _c2(11);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? ["id"] : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const primaryKeys = t1;
+  const supabase = useSupabase();
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  let t2;
+  if ($[2] !== primaryKeys) {
+    t2 = primaryKeys.map(_temp3);
+    $[2] = primaryKeys;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const primaryKeysAsStrings = t2;
+  const t3 = supabase;
+  let t4;
+  if ($[4] !== schemaName || $[5] !== t3 || $[6] !== tableName) {
+    t4 = t3.schema(schemaName).from(tableName);
+    $[4] = schemaName;
+    $[5] = t3;
+    $[6] = tableName;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  const mutation = useInsertMutation(t4, primaryKeysAsStrings, query, mutationOption);
+  let t5;
+  if ($[8] !== mutation || $[9] !== primaryKeys) {
+    t5 = {
+      mutationFn: async (item) => {
+        const primaryKeysNull = primaryKeys.filter((x) => x in item === false || isUsable(item[x]) === false).map(_temp2);
+        const response = await mutation.mutateAsync([omit(item, primaryKeysNull)]);
+        mutation.reset();
+        return response?.[0];
+      }
+    };
+    $[8] = mutation;
+    $[9] = primaryKeys;
+    $[10] = t5;
+  } else {
+    t5 = $[10];
+  }
+  const updateMutation = useMutation2(t5);
+  return updateMutation;
+}
+function _temp2(k_0) {
+  return String(k_0);
+}
+function _temp3(k) {
+  return String(k);
+}
+
+// src/useDbMultiDelete.ts
+import { c as _c3 } from "react/compiler-runtime";
+import { useMutation as useMutation3 } from "@tanstack/react-query";
+function useDbMultiDelete(relation, t0) {
+  const $ = _c3(10);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? ["id"] : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const primaryKeys = t1;
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  const supabase = useSupabase();
+  let t2;
+  if ($[2] !== primaryKeys) {
+    t2 = primaryKeys.map(_temp4);
+    $[2] = primaryKeys;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const primaryKeysAsStrings = t2;
+  const t3 = supabase;
+  let t4;
+  if ($[4] !== schemaName || $[5] !== t3 || $[6] !== tableName) {
+    t4 = t3.schema(schemaName).from(tableName);
+    $[4] = schemaName;
+    $[5] = t3;
+    $[6] = tableName;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  const deleteManyMutation = useDeleteManyMutation(t4, primaryKeysAsStrings);
+  let t5;
+  if ($[8] !== deleteManyMutation) {
+    t5 = {
+      mutationFn: async (item) => {
+        if (Array.isArray(item)) {
+          const response = await deleteManyMutation.mutateAsync(item);
+          return response;
+        } else {
+          throw new Error("Item must be an array.");
+        }
+      }
+    };
+    $[8] = deleteManyMutation;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  const deleteMutation = useMutation3(t5);
+  return deleteMutation;
+}
+function _temp4(k) {
+  return String(k);
+}
+
+// src/useDbMultiUpsert.ts
+import { c as _c4 } from "react/compiler-runtime";
+import { useMutation as useMutation4 } from "@tanstack/react-query";
+function useDbMultiUpsert(relation, t0, t1) {
+  const $ = _c4(17);
+  let t2;
+  if ($[0] !== t0) {
+    t2 = t0 === void 0 ? ["id"] : t0;
+    $[0] = t0;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  const primaryKeys = t2;
+  const query = t1 === void 0 ? "*" : t1;
+  const supabase = useSupabase();
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  const t3 = relation;
+  let t4;
+  if ($[2] !== primaryKeys || $[3] !== t3) {
+    t4 = {
+      primaryKeys,
+      table: t3,
+      schema: "public"
+    };
+    $[2] = primaryKeys;
+    $[3] = t3;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  const upsertItem = useUpsertItem(t4);
+  let t5;
+  if ($[5] !== primaryKeys) {
+    t5 = primaryKeys.map(_temp5);
+    $[5] = primaryKeys;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  const primaryKeysAsStrings = t5;
+  let t6;
+  if ($[7] !== primaryKeys || $[8] !== primaryKeysAsStrings || $[9] !== query || $[10] !== schemaName || $[11] !== supabase || $[12] !== tableName) {
+    t6 = async function upsertItemAction2(item) {
+      let task;
+      if (Object.keys(item).length !== primaryKeys.length && primaryKeys.every((key_0) => key_0 in item && isUsable(item[key_0]))) {
+        const updateObject = omit(item, primaryKeysAsStrings);
+        task = supabase.schema(schemaName).from(tableName).update(updateObject);
+        primaryKeys.forEach((key) => {
+          task = task.eq(String(key), item[key]);
+        });
+      } else {
+        task = supabase.schema(schemaName).from(tableName).insert(omit(item, primaryKeysAsStrings));
+      }
+      const response = await task.select(query);
+      if (response.error) {
+        throw response.error;
+      }
+      return response.data[0];
+    };
+    $[7] = primaryKeys;
+    $[8] = primaryKeysAsStrings;
+    $[9] = query;
+    $[10] = schemaName;
+    $[11] = supabase;
+    $[12] = tableName;
+    $[13] = t6;
+  } else {
+    t6 = $[13];
+  }
+  const upsertItemAction = t6;
+  let t7;
+  if ($[14] !== upsertItem || $[15] !== upsertItemAction) {
+    t7 = {
+      mutationFn: async (item_0) => {
+        if (Array.isArray(item_0)) {
+          const data = await Promise.all(item_0.map((x) => upsertItemAction(x)));
+          data.filter(_temp22).forEach((x_1) => upsertItem(x_1));
+          return data;
+        }
+        throw new Error("Item must be an array.");
+      }
+    };
+    $[14] = upsertItem;
+    $[15] = upsertItemAction;
+    $[16] = t7;
+  } else {
+    t7 = $[16];
+  }
+  const updateMutation = useMutation4(t7);
+  return updateMutation;
+}
+function _temp22(x_0) {
+  return isUsable(x_0);
+}
+function _temp5(k) {
+  return String(k);
+}
+
+// src/useDbPartialAdvanceQuery.ts
+import { c as _c5 } from "react/compiler-runtime";
+import { useLayoutEffect, useState } from "react";
+import { useSessionStorageState } from "@pol-studios/hooks/storage";
+function useDbPartialAdvanceQuery(query, itemCountPerPage, config) {
+  const $ = _c5(54);
+  const initialQuery = encode(query, false);
+  const [id, setId] = useState(window.location.pathname);
+  const [currentPage, setCurrentPage] = useSessionStorageState(`${id}-currentPage`, 1);
+  const page = currentPage ?? 1;
+  const t0 = query;
+  let t1;
+  if ($[0] !== itemCountPerPage || $[1] !== page || $[2] !== t0) {
+    t1 = t0.range((page - 1) * itemCountPerPage, page * itemCountPerPage - 1);
+    $[0] = itemCountPerPage;
+    $[1] = page;
+    $[2] = t0;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const rangedQuery = t1;
+  const t2 = config?.filterKey;
+  const t3 = currentPage ?? 1;
+  let t4;
+  if ($[4] !== t3) {
+    t4 = t3.toString();
+    $[4] = t3;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  let t5;
+  if ($[6] !== config || $[7] !== t2 || $[8] !== t4) {
+    t5 = {
+      ...config,
+      filterKey: t2,
+      count: "exact",
+      key: t4
+    };
+    $[6] = config;
+    $[7] = t2;
+    $[8] = t4;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  const [baseQuery, filter, setFilters] = useDbAdvanceFilterQuery(rangedQuery, t5);
+  let t6;
+  if ($[10] !== filter) {
+    t6 = JSON.stringify(omit(filter, ["pagination"]));
+    $[10] = filter;
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  const filterKey = t6;
+  const select = initialQuery[4].split("&").find(_temp6);
+  let t7;
+  if ($[12] !== filterKey || $[13] !== id || $[14] !== initialQuery[3] || $[15] !== initialQuery[5] || $[16] !== initialQuery[6] || $[17] !== initialQuery[7] || $[18] !== initialQuery[8] || $[19] !== select || $[20] !== setId) {
+    t7 = () => {
+      const newId = [initialQuery[3], select, initialQuery[5], initialQuery[6], initialQuery[7], initialQuery[8], filterKey].join("-");
+      console.log({
+        newId,
+        id
+      });
+      setId(newId);
+    };
+    $[12] = filterKey;
+    $[13] = id;
+    $[14] = initialQuery[3];
+    $[15] = initialQuery[5];
+    $[16] = initialQuery[6];
+    $[17] = initialQuery[7];
+    $[18] = initialQuery[8];
+    $[19] = select;
+    $[20] = setId;
+    $[21] = t7;
+  } else {
+    t7 = $[21];
+  }
+  let t8;
+  if ($[22] !== filterKey || $[23] !== initialQuery[3] || $[24] !== initialQuery[5] || $[25] !== initialQuery[6] || $[26] !== initialQuery[7] || $[27] !== initialQuery[8] || $[28] !== select) {
+    t8 = [initialQuery[3], select, initialQuery[5], initialQuery[6], initialQuery[7], initialQuery[8], filterKey];
+    $[22] = filterKey;
+    $[23] = initialQuery[3];
+    $[24] = initialQuery[5];
+    $[25] = initialQuery[6];
+    $[26] = initialQuery[7];
+    $[27] = initialQuery[8];
+    $[28] = select;
+    $[29] = t8;
+  } else {
+    t8 = $[29];
+  }
+  useLayoutEffect(t7, t8);
+  let t9;
+  if ($[30] !== setCurrentPage) {
+    t9 = () => {
+      setCurrentPage(_temp23);
+    };
+    $[30] = setCurrentPage;
+    $[31] = t9;
+  } else {
+    t9 = $[31];
+  }
+  const safeFetchNextPage = t9;
+  let t10;
+  if ($[32] !== setCurrentPage) {
+    t10 = () => {
+      setCurrentPage(_temp32);
+    };
+    $[32] = setCurrentPage;
+    $[33] = t10;
+  } else {
+    t10 = $[33];
+  }
+  const fetchPreviousPage = t10;
+  const pageCount = Math.max(Math.ceil((baseQuery.count ?? 0) / itemCountPerPage), 1);
+  const t11 = currentPage ?? 1;
+  let t12;
+  if ($[34] !== baseQuery.count || $[35] !== baseQuery.data || $[36] !== currentPage || $[37] !== itemCountPerPage) {
+    t12 = baseQuery.data ? toPagedResponse(baseQuery.data, currentPage ?? 1, baseQuery.count ?? baseQuery.data.length, itemCountPerPage) : null;
+    $[34] = baseQuery.count;
+    $[35] = baseQuery.data;
+    $[36] = currentPage;
+    $[37] = itemCountPerPage;
+    $[38] = t12;
+  } else {
+    t12 = $[38];
+  }
+  const t13 = (currentPage ?? 1) < pageCount;
+  const t14 = (currentPage ?? 1) > 1;
+  const t15 = baseQuery.count ?? baseQuery.data?.length;
+  let t16;
+  if ($[39] !== baseQuery || $[40] !== fetchPreviousPage || $[41] !== pageCount || $[42] !== safeFetchNextPage || $[43] !== setCurrentPage || $[44] !== t11 || $[45] !== t12 || $[46] !== t13 || $[47] !== t14 || $[48] !== t15) {
+    t16 = {
+      ...baseQuery,
+      clarification: baseQuery.clarification,
+      fetchPreviousPage,
+      fetchNextPage: safeFetchNextPage,
+      currentPage: t11,
+      setCurrentPage,
+      data: t12,
+      pageCount,
+      hasNextPage: t13,
+      hasPreviousPage: t14,
+      count: t15
+    };
+    $[39] = baseQuery;
+    $[40] = fetchPreviousPage;
+    $[41] = pageCount;
+    $[42] = safeFetchNextPage;
+    $[43] = setCurrentPage;
+    $[44] = t11;
+    $[45] = t12;
+    $[46] = t13;
+    $[47] = t14;
+    $[48] = t15;
+    $[49] = t16;
+  } else {
+    t16 = $[49];
+  }
+  const request = t16;
+  let t17;
+  if ($[50] !== filter || $[51] !== request || $[52] !== setFilters) {
+    t17 = [request, filter, setFilters];
+    $[50] = filter;
+    $[51] = request;
+    $[52] = setFilters;
+    $[53] = t17;
+  } else {
+    t17 = $[53];
+  }
+  return t17;
+}
+function _temp32(currentPage_1) {
+  return (currentPage_1 ?? 1) - 1;
+}
+function _temp23(currentPage_0) {
+  return (currentPage_0 ?? 1) + 1;
+}
+function _temp6(x) {
+  return x.startsWith("select=");
+}
+function toPagedResponse(results, currentPage, totalCount, itemPerPage) {
+  const newPage = {
+    Items: results,
+    CurrentPage: currentPage,
+    ItemCount: totalCount,
+    MaxCountPerPage: itemPerPage,
+    PageCount: Math.max(Math.ceil(totalCount / itemPerPage), 1)
+  };
+  return newPage;
+}
+
+// src/useDbPartialQuery.ts
+import { c as _c6 } from "react/compiler-runtime";
+import { useSessionStorageState as useSessionStorageState2 } from "@pol-studios/hooks/storage";
+function useDbPartialQuery(query, itemCountPerPage, config) {
+  const $ = _c6(28);
+  let t0;
+  if ($[0] !== query) {
+    t0 = encode(query, false);
+    $[0] = query;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const initialQuery = t0;
+  let t1;
+  if ($[2] !== initialQuery[7] || $[3] !== initialQuery[8]) {
+    t1 = [initialQuery[7], initialQuery[8]];
+    $[2] = initialQuery[7];
+    $[3] = initialQuery[8];
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const id = t1.join("-");
+  const [currentPage, setCurrentPage] = useSessionStorageState2(id, 1);
+  const page = currentPage ?? 1;
+  const t2 = query;
+  let t3;
+  if ($[5] !== itemCountPerPage || $[6] !== page || $[7] !== t2) {
+    t3 = t2.range((page - 1) * itemCountPerPage, page * itemCountPerPage - 1);
+    $[5] = itemCountPerPage;
+    $[6] = page;
+    $[7] = t2;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  const rangedQuery = t3;
+  const baseQuery = useDbQuery(rangedQuery, config);
+  let t4;
+  if ($[9] !== setCurrentPage) {
+    t4 = () => {
+      setCurrentPage(_temp7);
+    };
+    $[9] = setCurrentPage;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  const safeFetchNextPage = t4;
+  let t5;
+  if ($[11] !== setCurrentPage) {
+    t5 = () => {
+      setCurrentPage(_temp24);
+    };
+    $[11] = setCurrentPage;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  const fetchPreviousPage = t5;
+  const pageCount = Math.max(Math.ceil((baseQuery.count ?? 0) / itemCountPerPage), 1);
+  const t6 = currentPage ?? 1;
+  let t7;
+  if ($[13] !== baseQuery.count || $[14] !== baseQuery.data || $[15] !== currentPage || $[16] !== itemCountPerPage) {
+    t7 = baseQuery.data ? toPagedResponse2(baseQuery.data, currentPage ?? 1, baseQuery.count ?? baseQuery.data.length, itemCountPerPage) : null;
+    $[13] = baseQuery.count;
+    $[14] = baseQuery.data;
+    $[15] = currentPage;
+    $[16] = itemCountPerPage;
+    $[17] = t7;
+  } else {
+    t7 = $[17];
+  }
+  const t8 = (currentPage ?? 1) < pageCount;
+  const t9 = (currentPage ?? 1) > 1;
+  let t10;
+  if ($[18] !== baseQuery || $[19] !== fetchPreviousPage || $[20] !== pageCount || $[21] !== safeFetchNextPage || $[22] !== setCurrentPage || $[23] !== t6 || $[24] !== t7 || $[25] !== t8 || $[26] !== t9) {
+    t10 = {
+      ...baseQuery,
+      fetchPreviousPage,
+      fetchNextPage: safeFetchNextPage,
+      currentPage: t6,
+      setCurrentPage,
+      data: t7,
+      pageCount,
+      hasNextPage: t8,
+      hasPreviousPage: t9
+    };
+    $[18] = baseQuery;
+    $[19] = fetchPreviousPage;
+    $[20] = pageCount;
+    $[21] = safeFetchNextPage;
+    $[22] = setCurrentPage;
+    $[23] = t6;
+    $[24] = t7;
+    $[25] = t8;
+    $[26] = t9;
+    $[27] = t10;
+  } else {
+    t10 = $[27];
+  }
+  return t10;
+}
+function _temp24(currentPage_1) {
+  return currentPage_1 - 1;
+}
+function _temp7(currentPage_0) {
+  return currentPage_0 + 1;
+}
+function toPagedResponse2(results, currentPage, totalCount, itemPerPage) {
+  const newPage = {
+    Items: results,
+    CurrentPage: currentPage,
+    ItemCount: totalCount,
+    MaxCountPerPage: itemPerPage,
+    PageCount: Math.max(Math.ceil(totalCount / itemPerPage), 1)
+  };
+  return newPage;
+}
+
+// src/useDbRealtime.ts
+import { c as _c7 } from "react/compiler-runtime";
+import { useEffect, useState as useState2, useRef as useRef2 } from "react";
+import { REALTIME_POSTGRES_CHANGES_LISTEN_EVENT } from "@supabase/supabase-js";
+import { useDelayedValue } from "@pol-studios/hooks/state";
+function useDbRealtime(key, query, table, primaryKeys, options) {
+  const $ = _c7(37);
+  const supabase = useSupabase();
+  const tableNameValue = typeof table === "string" ? table : table.table;
+  const schemaValue = typeof table === "string" ? "public" : table.schema;
+  const queriesForTable = useQueriesForTableLoader(tableNameValue);
+  let t0;
+  if ($[0] !== primaryKeys || $[1] !== schemaValue || $[2] !== tableNameValue) {
+    t0 = {
+      primaryKeys,
+      table: tableNameValue,
+      schema: schemaValue
+    };
+    $[0] = primaryKeys;
+    $[1] = schemaValue;
+    $[2] = tableNameValue;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  const deleteItem = useDeleteItem(t0);
+  let t1;
+  if ($[4] !== primaryKeys || $[5] !== schemaValue || $[6] !== tableNameValue) {
+    t1 = {
+      primaryKeys,
+      table: tableNameValue,
+      schema: schemaValue
+    };
+    $[4] = primaryKeys;
+    $[5] = schemaValue;
+    $[6] = tableNameValue;
+    $[7] = t1;
+  } else {
+    t1 = $[7];
+  }
+  const upsertItem = useUpsertItem(t1);
+  const [realtimeState, setRealtimeState] = useState2("CLOSED");
+  const [retryTick, setRetryTick] = useState2(0);
+  const channelRef = useRef2(null);
+  const lastRetryTimeRef = useRef2(0);
+  const retryCountRef = useRef2(0);
+  const enabled = options?.enabled ?? true;
+  const filter = options?.filter;
+  const onChange = options?.onChange;
+  const debouncedKey = useDelayedValue(key, 50);
+  let t2;
+  if ($[8] !== deleteItem || $[9] !== enabled || $[10] !== filter || $[11] !== onChange || $[12] !== primaryKeys || $[13] !== queriesForTable || $[14] !== query || $[15] !== retryTick || $[16] !== schemaValue || $[17] !== supabase || $[18] !== tableNameValue || $[19] !== upsertItem) {
+    t2 = () => {
+      if (!enabled) {
+        if (channelRef.current) {
+          channelRef.current.unsubscribe();
+          supabase.removeChannel(channelRef.current);
+          channelRef.current = null;
+        }
+        setRealtimeState("CLOSED");
+        return;
+      }
+      const now = Date.now();
+      const timeSinceLastRetry = now - lastRetryTimeRef.current;
+      if (timeSinceLastRetry < 2e3 && retryTick > 0) {
+        return;
+      }
+      if (channelRef.current) {
+        channelRef.current.unsubscribe();
+        supabase.removeChannel(channelRef.current);
+        channelRef.current = null;
+      }
+      lastRetryTimeRef.current = now;
+      retryCountRef.current = retryCountRef.current + 1;
+      const channel = supabase.channel(newUuid()).on("postgres_changes", {
+        event: "*",
+        schema: schemaValue,
+        table: tableNameValue,
+        filter
+      }, async (payload) => {
+        let data = payload.new ?? payload.old;
+        if (payload.new && Object.keys(payload.new).length > 0) {
+          const selectQuery = buildNormalizedQuery({
+            queriesForTable,
+            query
+          });
+          if (payload.eventType !== REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE && selectQuery) {
+            if (selectQuery.groupedUserQueryPaths?.every((x) => x.path in data) === false) {
+              const qb = supabase.schema(payload.schema).from(payload.table).select(selectQuery.selectQuery);
+              for (const pk of primaryKeys) {
+                qb.eq(pk.toString(), data[pk]);
+              }
+              const res = await qb.single();
+              if (res.data) {
+                data = normalizeResponse(selectQuery.groupedPaths, res.data);
+              }
+            }
+          }
+          if ("changedBySessionId" in data) {
+            const sessionId = data.changedBySessionId;
+            if (sessionId !== UserSessionId) {
+              await upsertItem(data);
+            }
+          } else {
+            await upsertItem(data);
+          }
+        }
+        if (payload.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE) {
+          await deleteItem(payload.old);
+        }
+        if (payload.errors?.length > 0) {
+          setRealtimeState("CHANNEL_ERROR");
+        }
+        if (onChange) {
+          onChange(payload);
+        }
+      }).on("postgres_changes", {
+        event: "DELETE",
+        schema: schemaValue,
+        table: tableNameValue
+      }, async (payload_0) => {
+        if (payload_0.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE) {
+          await deleteItem(payload_0.old);
+        }
+      }).subscribe((status) => {
+        setRealtimeState(status);
+        if (status === "SUBSCRIBED") {
+          retryCountRef.current = 0;
+        }
+      });
+      channelRef.current = channel;
+      return () => {
+        if (channelRef.current) {
+          channelRef.current.unsubscribe();
+          supabase.removeChannel(channelRef.current);
+          channelRef.current = null;
+        }
+      };
+    };
+    $[8] = deleteItem;
+    $[9] = enabled;
+    $[10] = filter;
+    $[11] = onChange;
+    $[12] = primaryKeys;
+    $[13] = queriesForTable;
+    $[14] = query;
+    $[15] = retryTick;
+    $[16] = schemaValue;
+    $[17] = supabase;
+    $[18] = tableNameValue;
+    $[19] = upsertItem;
+    $[20] = t2;
+  } else {
+    t2 = $[20];
+  }
+  let t3;
+  if ($[21] !== primaryKeys) {
+    t3 = primaryKeys.join(",");
+    $[21] = primaryKeys;
+    $[22] = t3;
+  } else {
+    t3 = $[22];
+  }
+  let t4;
+  if ($[23] !== debouncedKey || $[24] !== enabled || $[25] !== filter || $[26] !== query || $[27] !== retryTick || $[28] !== schemaValue || $[29] !== supabase || $[30] !== t3 || $[31] !== tableNameValue) {
+    t4 = [supabase, tableNameValue, schemaValue, enabled, filter, query, t3, retryTick, debouncedKey];
+    $[23] = debouncedKey;
+    $[24] = enabled;
+    $[25] = filter;
+    $[26] = query;
+    $[27] = retryTick;
+    $[28] = schemaValue;
+    $[29] = supabase;
+    $[30] = t3;
+    $[31] = tableNameValue;
+    $[32] = t4;
+  } else {
+    t4 = $[32];
+  }
+  useEffect(t2, t4);
+  let t5;
+  let t6;
+  if ($[33] !== enabled || $[34] !== realtimeState) {
+    t5 = () => {
+      if (!enabled || realtimeState === "SUBSCRIBED") {
+        retryCountRef.current = 0;
+        return;
+      }
+      const delay = Math.min(5e3 * Math.pow(2, retryCountRef.current), 6e4);
+      const id = setTimeout(() => {
+        setRetryTick(_temp8);
+      }, delay);
+      return () => clearTimeout(id);
+    };
+    t6 = [realtimeState, enabled];
+    $[33] = enabled;
+    $[34] = realtimeState;
+    $[35] = t5;
+    $[36] = t6;
+  } else {
+    t5 = $[35];
+    t6 = $[36];
+  }
+  useEffect(t5, t6);
+  return realtimeState;
+}
+function _temp8(t) {
+  return t + 1;
+}
+
+// src/useDbRealtimeQuery.tsx
+import { c as _c8 } from "react/compiler-runtime";
+function convertFilterToRealtimeQuery(filters) {
+  function convert(filter) {
+    if (!filter) return "";
+    if ("path" in filter) {
+      if (filter.path.includes(".")) return "";
+      let valueString = filter.value?.toString() ?? "null";
+      if (filter.operator === "in") {
+        valueString = '("' + valueString.slice(2, valueString.length - 2).split(",").join('","') + '")';
+      }
+      return `${filter.path}=${filter.negate ? "not." : ""}${filter.operator}.${valueString}`;
+    } else {
+      if (filter.or) {
+        return `(${filter.or.map((f) => convert(f)).join("|")})`;
+      } else if (filter.and) {
+        return `(${filter.and.map((f) => convert(f)).join("&")})`;
+      }
+    }
+    return "";
+  }
+  return convert(filters[0]);
+}
+function useDbRealtimeQuery(query, config, t0) {
+  const $ = _c8(27);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? ["id"] : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const primaryKeys = t1;
+  const t2 = query;
+  let t3;
+  if ($[2] !== t2) {
+    t3 = new PostgrestParser(t2);
+    $[2] = t2;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  const parser = t3;
+  const request = useQuery(query, config);
+  let filter;
+  let selectStatement;
+  let t4;
+  let t5;
+  if ($[4] !== parser.filters || $[5] !== parser.select || $[6] !== query || $[7] !== request.data) {
+    const queryKey = encode(query, false);
+    let t62;
+    if ($[12] !== parser.filters || $[13] !== request.data) {
+      const filterString = convertFilterToRealtimeQuery(parser.filters);
+      filter = request.data && typeof request.data === "object" && "id" in request.data ? "id=eq." + request.data.id : filterString;
+      if (filter.includes('in.(\\"\\")')) {
+        filter = void 0;
+      }
+      t62 = isNullOrWhitespace(filter);
+      $[12] = parser.filters;
+      $[13] = request.data;
+      $[14] = filter;
+      $[15] = t62;
+    } else {
+      filter = $[14];
+      t62 = $[15];
+    }
+    if (t62) {
+      filter = void 0;
+    }
+    selectStatement = parser.select;
+    t4 = useDbRealtime;
+    t5 = queryKey.join("-");
+    $[4] = parser.filters;
+    $[5] = parser.select;
+    $[6] = query;
+    $[7] = request.data;
+    $[8] = filter;
+    $[9] = selectStatement;
+    $[10] = t4;
+    $[11] = t5;
+  } else {
+    filter = $[8];
+    selectStatement = $[9];
+    t4 = $[10];
+    t5 = $[11];
+  }
+  let t6;
+  if ($[16] !== parser.schema || $[17] !== parser.table) {
+    t6 = {
+      schema: parser.schema,
+      table: parser.table
+    };
+    $[16] = parser.schema;
+    $[17] = parser.table;
+    $[18] = t6;
+  } else {
+    t6 = $[18];
+  }
+  const t7 = typeof config?.enabled === "boolean" ? config.enabled : true;
+  let t8;
+  if ($[19] !== filter || $[20] !== t7) {
+    t8 = {
+      filter,
+      enabled: t7
+    };
+    $[19] = filter;
+    $[20] = t7;
+    $[21] = t8;
+  } else {
+    t8 = $[21];
+  }
+  const realtimeStatus = t4(t5, selectStatement, t6, primaryKeys, t8);
+  const outputRealtimeStatus = request.isFetching ? "Loading..." : realtimeStatus;
+  const t9 = request.data;
+  const t10 = realtimeStatus == "SUBSCRIBED";
+  let t11;
+  if ($[22] !== outputRealtimeStatus || $[23] !== request || $[24] !== t10 || $[25] !== t9) {
+    t11 = {
+      ...request,
+      data: t9,
+      realtimeStatus: outputRealtimeStatus,
+      isRealtimeConnected: t10,
+      isRealtimeLoading: request.isFetching
+    };
+    $[22] = outputRealtimeStatus;
+    $[23] = request;
+    $[24] = t10;
+    $[25] = t9;
+    $[26] = t11;
+  } else {
+    t11 = $[26];
+  }
+  return t11;
+}
+
+// src/useDbUpdate.ts
+import { c as _c9 } from "react/compiler-runtime";
+import { useMutation as useMutation5 } from "@tanstack/react-query";
+function useDbUpdate(relation, t0, query, mutationOption) {
+  const $ = _c9(14);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? ["id"] : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const primaryKeys = t1;
+  const supabase = useSupabase();
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  let t2;
+  if ($[2] !== primaryKeys) {
+    t2 = primaryKeys.map(_temp9);
+    $[2] = primaryKeys;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const primaryKeysAsStrings = t2;
+  const t3 = primaryKeysAsStrings;
+  const t4 = relation;
+  let t5;
+  if ($[4] !== t3 || $[5] !== t4) {
+    t5 = {
+      primaryKeys: t3,
+      table: t4,
+      schema: "public"
+    };
+    $[4] = t3;
+    $[5] = t4;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  const upsertItem = useUpsertItem(t5);
+  let t6;
+  if ($[7] !== primaryKeys || $[8] !== primaryKeysAsStrings || $[9] !== schemaName || $[10] !== supabase || $[11] !== tableName || $[12] !== upsertItem) {
+    t6 = {
+      mutationFn: async (item) => {
+        let response = null;
+        if (primaryKeys.every((x_0) => x_0 in item && isUsable(item[x_0]))) {
+          const query_0 = supabase.schema(schemaName).from(tableName).update(omit(item, primaryKeysAsStrings));
+          primaryKeys.forEach((x) => {
+            query_0.eq(String(x), item[x]);
+          });
+          const queryResponse = await query_0.select().single().throwOnError();
+          if (queryResponse.data) {
+            response = queryResponse.data;
+            upsertItem(response);
+          }
+        }
+        return response;
+      }
+    };
+    $[7] = primaryKeys;
+    $[8] = primaryKeysAsStrings;
+    $[9] = schemaName;
+    $[10] = supabase;
+    $[11] = tableName;
+    $[12] = upsertItem;
+    $[13] = t6;
+  } else {
+    t6 = $[13];
+  }
+  const updateMutation = useMutation5(t6);
+  return updateMutation;
+}
+function _temp9(k) {
+  return String(k);
+}
+
+// src/useMutationSuccess.ts
+import { c as _c10 } from "react/compiler-runtime";
+import { useEffect as useEffect2, useRef as useRef3 } from "react";
+function useMutationSuccess(mutation, t0) {
+  const $ = _c10(10);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const options = t1;
+  const {
+    successMessage,
+    entityName,
+    enabled: t2,
+    onSuccess
+  } = options;
+  const enabled = t2 === void 0 ? true : t2;
+  const previousSuccessRef = useRef3(false);
+  const previousDataRef = useRef3(void 0);
+  let t3;
+  let t4;
+  if ($[2] !== enabled || $[3] !== entityName || $[4] !== mutation.data || $[5] !== mutation.isSuccess || $[6] !== onSuccess || $[7] !== successMessage) {
+    t3 = () => {
+      if (!enabled) {
+        return;
+      }
+      const isSuccess = mutation.isSuccess;
+      const hasNewData = mutation.data !== previousDataRef.current;
+      if (isSuccess && hasNewData && !previousSuccessRef.current) {
+        const message = successMessage || getDefaultSuccessMessage(entityName);
+        if (typeof window !== "undefined") {
+          try {
+            const {
+              toast
+            } = __require("@pol-studios/hooks");
+            toast.toast({
+              title: "Success",
+              description: message
+            });
+          } catch {
+          }
+        } else {
+          try {
+            const {
+              Toast
+            } = __require("toastify-react-native");
+            Toast.success(message);
+          } catch {
+          }
+        }
+        onSuccess?.();
+      }
+      previousSuccessRef.current = isSuccess;
+      previousDataRef.current = mutation.data;
+    };
+    t4 = [mutation.isSuccess, mutation.data, enabled, successMessage, entityName, onSuccess];
+    $[2] = enabled;
+    $[3] = entityName;
+    $[4] = mutation.data;
+    $[5] = mutation.isSuccess;
+    $[6] = onSuccess;
+    $[7] = successMessage;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t3 = $[8];
+    t4 = $[9];
+  }
+  useEffect2(t3, t4);
+  return mutation;
+}
+function getDefaultSuccessMessage(entityName) {
+  if (!entityName) {
+    return "Saved successfully";
+  }
+  return `${entityName} saved successfully`;
+}
+function useMutationSuccessRN(mutation, t0) {
+  const $ = _c10(2);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const options = t1;
+  return useMutationSuccess(mutation, options);
+}
+
+// src/adapters/types.ts
+var ADAPTER_STRATEGIES = {
+  POWERSYNC: "powersync",
+  SUPABASE: "supabase",
+  CACHED: "cached",
+  HYBRID: "hybrid",
+  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 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 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";
+    }
+    const result = {
+      powerSyncStatus,
+      supabaseStatus,
+      recommendedBackend,
+      isOnline,
+      reason
+    };
+    if (this.hasResultChanged(result)) {
+      this.lastResult = result;
+      this.notifyListeners(result);
+    }
+    return result;
+  }
+  /**
+   * 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 && this.syncStatus) {
+        if (!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 true by default for other environments.
+   *
+   * @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 true;
+  }
+  // ===========================================================================
+  // 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) {
+    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/registry.ts
+var AdapterRegistry = class {
+  /**
+   * Create a new adapter registry
+   *
+   * @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)
+   */
+  powerSyncAdapter = 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;
+  /**
+   * 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;
+  }
+  /**
+   * 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.
+   *
+   * @param table - The table name
+   * @returns The appropriate adapter for the table
+   * @throws Error if adapters are not initialized
+   */
+  getAdapter(table) {
+    const strategy = this.config.tables[table];
+    if (!strategy || strategy.strategy === "auto") {
+      if (this.powerSyncAdapter) {
+        const powerSyncTables = this.getPowerSyncTables();
+        if (!powerSyncTables.includes(table)) {
+          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);
+    }
+    if (strategy.strategy === "powersync" && this.autoDetector && this.supabaseAdapter) {
+      const detection = this.autoDetector.detect();
+      if (detection.powerSyncStatus === "initializing" /* INITIALIZING */ && detection.isOnline) {
+        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
+   */
+  getPowerSyncAdapter() {
+    return this.powerSyncAdapter;
+  }
+  /**
+   * Get the Supabase adapter directly
+   *
+   * @returns Supabase adapter or null if not initialized
+   */
+  getSupabaseAdapter() {
+    return this.supabaseAdapter;
+  }
+  /**
+   * Get the Cached adapter directly
+   *
+   * @returns Cached adapter or null if not initialized
+   */
+  getCachedAdapter() {
+    return this.cachedAdapter;
+  }
+  /**
+   * Get all configured table names
+   *
+   * @returns Array of table names with explicit strategy configuration
+   */
+  getConfiguredTables() {
+    return Object.keys(this.config.tables);
+  }
+  /**
+   * Get the strategy for a specific table
+   *
+   * @param table - The table name
+   * @returns The table strategy or undefined if not configured
+   */
+  getTableStrategy(table) {
+    return this.config.tables[table];
+  }
+  /**
+   * Check if a table uses PowerSync strategy
+   *
+   * @param table - The table name
+   * @returns True if table uses PowerSync or Hybrid strategy
+   */
+  usesPowerSync(table) {
+    const strategy = this.config.tables[table];
+    return strategy?.strategy === "powersync" || strategy?.strategy === "hybrid";
+  }
+  /**
+   * Get all tables that use PowerSync
+   *
+   * @returns Array of table names using PowerSync or Hybrid strategy
+   */
+  getPowerSyncTables() {
+    return Object.entries(this.config.tables).filter(([_, strategy]) => strategy.strategy === "powersync" || strategy.strategy === "hybrid").map(([table]) => table);
+  }
+  // ===========================================================================
+  // Auto-Detection Methods
+  // ===========================================================================
+  /**
+   * Get adapter using auto-detection
+   *
+   * @param strategy - Optional auto strategy configuration
+   * @returns The automatically selected adapter
+   */
+  getAutoAdapter(strategy) {
+    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.");
+      }
+      return this.supabaseAdapter;
+    }
+    const detection = this.autoDetector.detect();
+    this.lastDetectionResult = detection;
+    if (detection.recommendedBackend === "powersync") {
+      if (!this.powerSyncAdapter) {
+        if (!this.supabaseAdapter) {
+          throw new Error("Neither PowerSync nor Supabase adapters are available.");
+        }
+        return this.supabaseAdapter;
+      }
+      return this.powerSyncAdapter;
+    }
+    if (!this.supabaseAdapter) {
+      throw new Error("Supabase adapter not available and PowerSync not recommended.");
+    }
+    return this.supabaseAdapter;
+  }
+  /**
+   * Subscribe to backend changes
+   *
+   * @param callback - Function called when recommended backend changes
+   * @returns Unsubscribe function
+   */
+  onBackendChange(callback) {
+    this.backendChangeListeners.add(callback);
+    return () => {
+      this.backendChangeListeners.delete(callback);
+    };
+  }
+  /**
+   * Notify listeners of backend change
+   *
+   * @param backend - The new recommended backend
+   */
+  notifyBackendChange(backend) {
+    this.backendChangeListeners.forEach((callback) => {
+      try {
+        callback(backend);
+      } catch (error) {
+        console.error("Error in backend change listener:", error);
+      }
+    });
+  }
+  /**
+   * Get the last auto-detection result
+   *
+   * @returns Last detection result or null if never detected
+   */
+  getLastDetectionResult() {
+    return this.lastDetectionResult;
+  }
+  /**
+   * Get the auto-detector instance
+   *
+   * @returns Auto-detector instance or null if not initialized
+   */
+  getAutoDetector() {
+    return this.autoDetector;
+  }
+  // ===========================================================================
+  // Private 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
+   */
+  createAdapter(strategy) {
+    switch (strategy.strategy) {
+      case "powersync":
+        if (!this.powerSyncAdapter) {
+          throw new Error("PowerSync adapter not initialized. Ensure PowerSyncAdapter is set before accessing PowerSync tables.");
+        }
+        return 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;
+    }
+  }
+  // ===========================================================================
+  // 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;
+  }
+  /**
+   * Dispose all adapters and clean up resources.
+   * Called when the DataLayerProvider unmounts.
+   */
+  dispose() {
+    this.reset();
+  }
+  /**
+   * Get debug information about the registry state
+   */
+  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/supabase-adapter.ts
+var SupabaseAdapter = class {
+  constructor(supabase, schema) {
+    this.supabase = supabase;
+    this.schema = schema;
+  }
+  name = "supabase";
+  capabilities = {
+    supportsSubscribe: true,
+    supportsOffline: false,
+    supportsCache: false,
+    supportsSync: false
+  };
+  // ===========================================================================
+  // Private Helper - Table Name Parsing
+  // ===========================================================================
+  /**
+   * Parse a table identifier to extract schema and table name.
+   * Handles schema-qualified names like "core.Profile" -> { schema: "core", tableName: "Profile" }
+   *
+   * @param table - The table name, optionally schema-qualified (e.g., "users" or "core.Profile")
+   * @returns Object with schema (defaults to "public") and tableName
+   */
+  parseTableIdentifier(table) {
+    if (table.includes(".")) {
+      const [schema, ...rest] = table.split(".");
+      return {
+        schema,
+        tableName: rest.join(".")
+      };
+    }
+    return {
+      schema: "public",
+      tableName: table
+    };
+  }
+  // ===========================================================================
+  // Query Operations
+  // ===========================================================================
+  /**
+   * Execute a query and return results with optional count
+   *
+   * @param table - The table name to query
+   * @param options - Query options (select, where, orderBy, limit, offset)
+   * @returns Promise resolving to query results with optional count
+   */
+  async query(table, options) {
+    const {
+      select = "*",
+      where,
+      orderBy,
+      limit,
+      offset
+    } = options;
+    const {
+      schema,
+      tableName
+    } = this.parseTableIdentifier(table);
+    let query = this.supabase.schema(schema).from(tableName).select(select, {
+      count: "exact"
+    });
+    if (where) {
+      query = this.applyWhereClause(query, where);
+    }
+    if (orderBy && orderBy.length > 0) {
+      for (const order of orderBy) {
+        query = query.order(order.field, {
+          ascending: order.direction === "asc"
+        });
+      }
+    }
+    if (limit !== void 0 && offset !== void 0) {
+      query = query.range(offset, offset + limit - 1);
+    } else if (limit !== void 0) {
+      query = query.limit(limit);
+    }
+    const {
+      data,
+      error,
+      count
+    } = await query;
+    if (error) {
+      throw new Error(`Supabase query error on ${table}: ${error.message}`);
+    }
+    return {
+      data: data ?? [],
+      count: count ?? void 0
+    };
+  }
+  /**
+   * Query a single record by ID
+   *
+   * @param table - The table name to query
+   * @param id - The record ID
+   * @param options - Optional query options (mainly for select)
+   * @returns Promise resolving to the record or null if not found
+   */
+  async queryById(table, id, options) {
+    const select = options?.select ?? "*";
+    const {
+      schema,
+      tableName
+    } = this.parseTableIdentifier(table);
+    const {
+      data,
+      error
+    } = await this.supabase.schema(schema).from(tableName).select(select).eq("id", id).single();
+    if (error) {
+      if (error.code === "PGRST116") {
+        return null;
+      }
+      throw new Error(`Supabase queryById error on ${table}: ${error.message}`);
+    }
+    return data;
+  }
+  // ===========================================================================
+  // Mutation Operations
+  // ===========================================================================
+  /**
+   * Insert a new record
+   *
+   * @param table - The table name
+   * @param data - The data to insert
+   * @returns Promise resolving to the inserted record
+   */
+  async insert(table, data) {
+    const {
+      schema,
+      tableName
+    } = this.parseTableIdentifier(table);
+    const {
+      data: insertedData,
+      error
+    } = await this.supabase.schema(schema).from(tableName).insert(data).select().single();
+    if (error) {
+      throw new Error(`Supabase insert error on ${table}: ${error.message}`);
+    }
+    return insertedData;
+  }
+  /**
+   * Update an existing record by ID
+   *
+   * @param table - The table name
+   * @param id - The record ID to update
+   * @param data - The data to update
+   * @returns Promise resolving to the updated record
+   */
+  async update(table, id, data) {
+    const {
+      schema,
+      tableName
+    } = this.parseTableIdentifier(table);
+    const {
+      data: updatedData,
+      error
+    } = await this.supabase.schema(schema).from(tableName).update(data).eq("id", id).select().single();
+    if (error) {
+      throw new Error(`Supabase update error on ${table}: ${error.message}`);
+    }
+    return updatedData;
+  }
+  /**
+   * Upsert (insert or update) a record
+   *
+   * @param table - The table name
+   * @param data - The data to upsert
+   * @returns Promise resolving to the upserted record
+   */
+  async upsert(table, data) {
+    const {
+      schema,
+      tableName
+    } = this.parseTableIdentifier(table);
+    const {
+      data: upsertedData,
+      error
+    } = await this.supabase.schema(schema).from(tableName).upsert(data, {
+      onConflict: "id"
+    }).select().single();
+    if (error) {
+      throw new Error(`Supabase upsert error on ${table}: ${error.message}`);
+    }
+    return upsertedData;
+  }
+  /**
+   * Delete a record by ID
+   *
+   * @param table - The table name
+   * @param id - The record ID to delete
+   * @returns Promise that resolves when deletion is complete
+   */
+  async delete(table, id) {
+    const {
+      schema,
+      tableName
+    } = this.parseTableIdentifier(table);
+    const {
+      error
+    } = await this.supabase.schema(schema).from(tableName).delete().eq("id", id);
+    if (error) {
+      throw new Error(`Supabase delete error on ${table}: ${error.message}`);
+    }
+  }
+  // ===========================================================================
+  // Subscription (Real-time)
+  // ===========================================================================
+  /**
+   * Subscribe to real-time changes on a query
+   *
+   * @param table - The table name to watch
+   * @param options - Query options to filter what to watch
+   * @param callback - Function called with updated data
+   * @returns Unsubscribe function
+   */
+  subscribe(table, options, callback) {
+    const {
+      schema,
+      tableName
+    } = this.parseTableIdentifier(table);
+    const channelName = `v3:${table}:${Date.now()}`;
+    const channel = this.supabase.channel(channelName).on("postgres_changes", {
+      event: "*",
+      schema,
+      table: tableName
+    }, async () => {
+      try {
+        const {
+          data
+        } = await this.query(table, options);
+        callback(data);
+      } catch (error) {
+        console.error(`Supabase subscription refetch error on ${table}:`, error);
+      }
+    }).subscribe();
+    return () => {
+      this.supabase.removeChannel(channel);
+    };
+  }
+  // ===========================================================================
+  // Private Helper Methods
+  // ===========================================================================
+  /**
+   * Apply where clause filters to a Supabase query
+   *
+   * Converts WhereClause to Supabase filter methods:
+   * - Direct value: .eq(field, value)
+   * - { in: [...] }: .in(field, values)
+   * - { gt: n }: .gt(field, n)
+   * - { gte: n }: .gte(field, n)
+   * - { lt: n }: .lt(field, n)
+   * - { lte: n }: .lte(field, n)
+   * - { like: s }: .ilike(field, s)
+   * - { is: null }: .is(field, null)
+   * - { neq: v }: .neq(field, v) or .not(field, "is", null)
+   * - { notIn: [...] }: .not().in(field, values)
+   *
+   * @param query - The Supabase query builder
+   * @param where - The where clause to apply
+   * @returns The query with filters applied
+   */
+  applyWhereClause(query, where) {
+    for (const [field, condition] of Object.entries(where)) {
+      if (condition === null) {
+        query = query.is(field, null);
+      } else if (typeof condition === "string" || typeof condition === "number" || typeof condition === "boolean") {
+        query = query.eq(field, condition);
+      } else if (typeof condition === "object") {
+        const operators = condition;
+        if (operators.in !== void 0) {
+          query = query.in(field, operators.in);
+        }
+        if (operators.gt !== void 0) {
+          query = query.gt(field, operators.gt);
+        }
+        if (operators.gte !== void 0) {
+          query = query.gte(field, operators.gte);
+        }
+        if (operators.lt !== void 0) {
+          query = query.lt(field, operators.lt);
+        }
+        if (operators.lte !== void 0) {
+          query = query.lte(field, operators.lte);
+        }
+        if (operators.like !== void 0) {
+          query = query.ilike(field, operators.like);
+        }
+        if (operators.is !== void 0) {
+          query = query.is(field, null);
+        }
+        if (operators.neq !== void 0) {
+          if (operators.neq === null) {
+            query = query.not(field, "is", null);
+          } else {
+            query = query.neq(field, operators.neq);
+          }
+        }
+        if (operators.notIn !== void 0) {
+          query = query.not(field, "in", `(${operators.notIn.join(",")})`);
+        }
+      }
+    }
+    return query;
+  }
+};
+function createSupabaseAdapter(supabase, schema) {
+  return new SupabaseAdapter(supabase, schema);
+}
+
+// src/supabase-functions.tsx
+async function getErrorBody(response) {
+  const stream = response.error.context.body;
+  const reader = stream.getReader();
+  const {
+    value
+  } = await reader.read();
+  const text = new TextDecoder().decode(value);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = text;
+  }
+  return parsed;
+}
+
+// src/useAI.ts
+import { c as _c11 } from "react/compiler-runtime";
+function useAI() {
+  const $ = _c11(2);
+  const supabase = useSupabase();
+  let t0;
+  if ($[0] !== supabase) {
+    const generate = async (prompt, context, options) => {
+      const response = await supabase.functions.invoke("ai", {
+        body: {
+          prompt,
+          context,
+          options
+        }
+      });
+      if (response.error) {
+        throw new Error(`Failed to invoke AI function: ${response.error.message}`);
+      }
+      if (response.data?.error) {
+        throw new Error(response.data.error);
+      }
+      if (!response.data?.success) {
+        throw new Error(response.data?.error || "Unknown error occurred");
+      }
+      if (!response.data?.data?.response) {
+        throw new Error("No response from AI");
+      }
+      return response.data.data.response;
+    };
+    t0 = {
+      generate
+    };
+    $[0] = supabase;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+
+// src/useServerAvailability.ts
+import { useState as useState3, useEffect as useEffect3, useCallback } from "react";
+var CHECK_TIMEOUT = 1e4;
+var CHECK_INTERVAL = 3e4;
+function useServerAvailability(options) {
+  const {
+    enabled = true,
+    checkInterval = CHECK_INTERVAL,
+    timeout = CHECK_TIMEOUT
+  } = options || {};
+  const [isAvailable, setIsAvailable] = useState3(null);
+  const [isChecking, setIsChecking] = useState3(false);
+  const [lastChecked, setLastChecked] = useState3(null);
+  const [error, setError] = useState3(null);
+  const checkAvailability = useCallback(async () => {
+    if (!enabled) return;
+    setIsChecking(true);
+    setError(null);
+    try {
+      const supabaseUrl = getSupabaseUrl();
+      const supabaseAnonKey = process.env.SUPABASE_ANON_KEY || process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY;
+      if (!supabaseUrl) {
+        throw new Error("Supabase URL is not configured");
+      }
+      if (!supabaseAnonKey) {
+        throw new Error("Supabase anon key is not configured");
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const healthCheckPromise = fetch(`${supabaseUrl}/rest/v1/`, {
+        method: "HEAD",
+        headers: {
+          apikey: supabaseAnonKey
+        },
+        signal: controller.signal
+      }).then((response) => {
+        clearTimeout(timeoutId);
+        return response.status < 500;
+      }).catch((err_0) => {
+        clearTimeout(timeoutId);
+        if (err_0.name === "AbortError") {
+          return false;
+        }
+        return false;
+      });
+      const available = await healthCheckPromise;
+      setIsAvailable(available);
+      setLastChecked(/* @__PURE__ */ new Date());
+      setError(null);
+    } catch (err) {
+      const error_0 = err instanceof Error ? err : new Error("Unknown error checking server availability");
+      setIsAvailable(false);
+      setError(error_0);
+      setLastChecked(/* @__PURE__ */ new Date());
+    } finally {
+      setIsChecking(false);
+    }
+  }, [enabled, timeout]);
+  useEffect3(() => {
+    if (enabled) {
+      checkAvailability();
+    }
+  }, [enabled, checkAvailability]);
+  useEffect3(() => {
+    if (!enabled || isAvailable !== false) return;
+    const intervalId = setInterval(() => {
+      checkAvailability();
+    }, checkInterval);
+    return () => clearInterval(intervalId);
+  }, [enabled, isAvailable, checkInterval, checkAvailability]);
+  return {
+    isAvailable,
+    isChecking,
+    lastChecked,
+    error,
+    checkAvailability
+  };
+}
+
+// src/useSearchQuery.ts
+import { useMemo as useMemo3 } from "react";
+import React from "react";
+function useSearchQuery(baseQuery, searchText, columns, options = {
+  isOptional: true,
+  additionCondition: []
+}) {
+  const original = React.useRef(null);
+  if (original.current?.lastQuery !== baseQuery) {
+    const b = baseQuery;
+    const urlValue = b.url;
+    const url = urlValue ? typeof urlValue === "string" ? new URL(urlValue) : new URL(urlValue.toString()) : new URL("http://localhost");
+    const method = b.method ?? "GET";
+    const headers = b.headers ?? {};
+    const body = method !== "GET" && method !== "HEAD" ? b.body ?? null : null;
+    const signal = b.signal ?? null;
+    original.current = {
+      lastQuery: baseQuery,
+      original: {
+        url,
+        method,
+        headers,
+        body,
+        signal
+      }
+    };
+  }
+  return useMemo3(() => {
+    const qb = baseQuery;
+    const {
+      url: url_0,
+      method: method_0,
+      body: body_0,
+      signal: signal_0
+    } = original.current.original;
+    qb.url = new URL(url_0.toString());
+    qb.method = method_0;
+    if (method_0 !== "GET" && method_0 !== "HEAD") {
+      qb.body = body_0;
+    } else {
+      delete qb.body;
+    }
+    qb.signal = signal_0;
+    const term = searchText.trim();
+    if (term) {
+      const clauses = columns.map((col) => {
+        const [tbl, colName] = col.split(".");
+        return `${colName ?? tbl}.ilike.%${escapeLikePattern(term)}%`;
+      });
+      clauses.push(...options.additionCondition.filter(Boolean));
+      qb.or(clauses.join(","), {
+        referencedTable: columns.find((c) => c.includes("."))?.split(".")[0]
+      });
+    } else if (!options.isOptional) {
+      const conds = options.additionCondition.filter(Boolean);
+      conds?.length ? qb.or(conds.join(",")) : qb.limit(0);
+    }
+    return qb;
+  }, [baseQuery, searchText, columns.join(","), options.isOptional, options.additionCondition.join(",")]);
+}
+function escapeLikePattern(text) {
+  return text?.replace(/[%_]/g, "\\$&");
+}
+
+// src/useLiveChangeTracking.ts
+import { c as _c12 } from "react/compiler-runtime";
+import { useEffect as useEffect4, useState as useState4 } from "react";
+var import_moment = __toESM(require_moment(), 1);
+function useLiveChangeTracking(tableName, item, action) {
+  const $ = _c12(12);
+  const [changeLog, setChangeLog] = useState4(null);
+  const [oldItem, setOldItem] = useState4(null);
+  const supabase = useSupabase();
+  let t0;
+  if ($[0] !== item || $[1] !== oldItem || $[2] !== supabase || $[3] !== tableName) {
+    t0 = () => {
+      setChangeLog(null);
+      if (isUsable(item) === false) {
+        return;
+      }
+      if (isUsable(oldItem) === false) {
+        setOldItem(item);
+        return;
+      }
+      const itemId = item.id;
+      if (isUsable(itemId) === false) {
+        return;
+      }
+      const changes = getObjectChanges(oldItem, item);
+      if (Object.keys(changes).length === 0) {
+        return;
+      }
+      supabase.schema("core").from("OperationLog").select().filter("tableName", "eq", tableName).filter("recordId", "eq", itemId).order("changeAt", {
+        ascending: false
+      }).limit(1).single().then((x) => {
+        if (isUsable(x.data) === false) {
+          return;
+        }
+        const data = x.data;
+        if (data.sessionId === UserSessionId) {
+          return;
+        }
+        const changeLog_0 = {
+          modifiedByUserId: data.changeBy,
+          changedOn: import_moment.default.utc(data.changeAt),
+          changes
+        };
+        setChangeLog(changeLog_0);
+      });
+      setOldItem(item);
+    };
+    $[0] = item;
+    $[1] = oldItem;
+    $[2] = supabase;
+    $[3] = tableName;
+    $[4] = t0;
+  } else {
+    t0 = $[4];
+  }
+  let t1;
+  if ($[5] !== item) {
+    t1 = [item];
+    $[5] = item;
+    $[6] = t1;
+  } else {
+    t1 = $[6];
+  }
+  useEffect4(t0, t1);
+  let t2;
+  if ($[7] !== action || $[8] !== changeLog) {
+    t2 = () => {
+      if (isUsable(changeLog) && action) {
+        action(changeLog.changes, changeLog);
+      }
+    };
+    $[7] = action;
+    $[8] = changeLog;
+    $[9] = t2;
+  } else {
+    t2 = $[9];
+  }
+  let t3;
+  if ($[10] !== changeLog) {
+    t3 = [changeLog];
+    $[10] = changeLog;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
+  }
+  useEffect4(t2, t3);
+  return changeLog;
+}
+
+// src/useLatestOperationLog.ts
+import { c as _c13 } from "react/compiler-runtime";
+function useLatestOperationLog(tableName, recordId) {
+  const $ = _c13(8);
+  const supabase = useSupabase();
+  const t0 = supabase;
+  let t1;
+  if ($[0] !== recordId || $[1] !== t0 || $[2] !== tableName) {
+    t1 = t0.schema("core").from("OperationLog").select(OperationLog.defaultQuery).eq("recordId", String(recordId)).eq("tableName", tableName).order("changeAt", {
+      ascending: false
+    }).limit(1).maybeSingle();
+    $[0] = recordId;
+    $[1] = t0;
+    $[2] = tableName;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  let t2;
+  if ($[4] !== recordId) {
+    t2 = isUsable(recordId);
+    $[4] = recordId;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] !== t2) {
+    t3 = {
+      refetchOnMount: true,
+      refetchOnWindowFocus: true,
+      staleTime: 0,
+      enabled: t2
+    };
+    $[6] = t2;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  return useDbQuery(t1, t3);
+}
+
+// src/useAutosaveState.ts
+import { useCallback as useCallback2, useEffect as useEffect5, useMemo as useMemo4, useRef as useRef5, useState as useState5 } from "react";
+function newTimeActivity(date) {
+  return {
+    activityDate: date.clone().startOf("day").toISOString(true),
+    description: "",
+    hasRequestBillableChange: false,
+    hasRequestVerification: false,
+    hours: 0,
+    userNotes: "",
+    adminNotes: "",
+    userId: null,
+    clientId: null,
+    projectId: null,
+    workingPhaseId: null,
+    roleId: null,
+    taskId: null,
+    subtaskId: null,
+    weeklyTimesheetId: null,
+    id: null,
+    BillingDetails: {
+      status: "Unknown",
+      id: null,
+      orderHint: "",
+      chargeTableId: null,
+      cosmosId: null,
+      amount: 0,
+      rate: 0,
+      type: "TimeActivity"
+    }
+  };
+}
+function getNewValue(action, prevState) {
+  return typeof action === "function" ? action(prevState) : action;
+}
+function useAutosaveState(relation, defaultValue, options) {
+  const [value, setValue] = useState5(() => defaultValue);
+  const [baseValue, setBaseValue] = useState5(() => defaultValue);
+  const baseValueRef = useRef5(defaultValue);
+  const pendingChangesRef = useRef5(/* @__PURE__ */ new Map());
+  const currentId = useRef5(null);
+  const newOptions = useMemo4(() => options ? {
+    ...options,
+    primaryKeys: options.primaryKeys ?? ["id"]
+  } : {
+    delay: 200,
+    primaryKeys: ["id"]
+  }, [options]);
+  const upsertMutation = useDbUpsert(relation, {
+    invalidateTables: [relation]
+  });
+  const saveEntityChanges = useCallback2(async (entityId) => {
+    if (__DEV__) {
+      console.log("[Autosave] saveEntityChanges called:", {
+        entityId,
+        relation,
+        hasPendingEntry: pendingChangesRef.current.has(entityId)
+      });
+    }
+    const pending = pendingChangesRef.current.get(entityId);
+    if (!pending) {
+      if (__DEV__) {
+        console.log("[Autosave] No pending changes found for entity:", entityId);
+      }
+      return;
+    }
+    const changes = diff(pending.baseValue, pending.currentValue);
+    if (__DEV__) {
+      console.log("[Autosave] Computed diff:", {
+        entityId,
+        relation,
+        changeKeys: Object.keys(changes),
+        changes,
+        baseValue: pending.baseValue,
+        currentValue: pending.currentValue
+      });
+    }
+    if (Object.keys(changes).length === 0) {
+      if (__DEV__) {
+        console.log("[Autosave] No changes detected, skipping save for:", entityId);
+      }
+      pendingChangesRef.current.delete(entityId);
+      return;
+    }
+    const patch = {
+      ...changes,
+      id: entityId
+    };
+    const finalPatch = newOptions.transformBeforeMutation ? newOptions.transformBeforeMutation(patch) : patch;
+    if (__DEV__) {
+      console.log("[Autosave] Calling mutateAsync:", {
+        entityId,
+        relation,
+        patch,
+        finalPatch,
+        hasTransform: !!newOptions.transformBeforeMutation
+      });
+    }
+    try {
+      const result = await upsertMutation.mutateAsync(finalPatch);
+      if (__DEV__) {
+        console.log("[Autosave] mutateAsync SUCCESS:", {
+          entityId,
+          relation,
+          finalPatch,
+          result
+        });
+      }
+      pendingChangesRef.current.delete(entityId);
+    } catch (error) {
+      if (__DEV__) {
+        console.error("[Autosave] mutateAsync FAILED:", {
+          entityId,
+          relation,
+          finalPatch,
+          error,
+          errorMessage: error instanceof Error ? error.message : String(error),
+          errorStack: error instanceof Error ? error.stack : void 0
+        });
+      }
+      throw error;
+    }
+  }, [relation, upsertMutation, newOptions.transformBeforeMutation]);
+  const updateValue = useCallback2((update) => {
+    setValue((prev) => {
+      const newValue = getNewValue(update, prev);
+      const entityId_0 = newValue.id;
+      if (!entityId_0) return newValue;
+      let pending_0 = pendingChangesRef.current.get(entityId_0);
+      if (!pending_0) {
+        pending_0 = {
+          baseValue: baseValueRef.current,
+          currentValue: newValue,
+          timeoutId: null
+        };
+        pendingChangesRef.current.set(entityId_0, pending_0);
+        if (__DEV__) {
+          console.log("[Autosave] Created new pending entry using baseValueRef:", {
+            entityId: entityId_0,
+            baseValueId: baseValueRef.current?.id
+          });
+        }
+      } else {
+        pending_0.currentValue = newValue;
+      }
+      if (pending_0.timeoutId) {
+        clearTimeout(pending_0.timeoutId);
+      }
+      pending_0.timeoutId = setTimeout(() => {
+        saveEntityChanges(entityId_0);
+      }, newOptions.delay);
+      return newValue;
+    });
+  }, [saveEntityChanges, newOptions.delay]);
+  const setNewEntity = useCallback2((newEntity) => {
+    baseValueRef.current = newEntity;
+    if (__DEV__) {
+      console.log("[Autosave] setNewEntity - baseValueRef updated synchronously:", {
+        entityId: newEntity.id,
+        relation
+      });
+    }
+    setValue(newEntity);
+    setBaseValue(newEntity);
+    currentId.current = newEntity.id;
+  }, [relation]);
+  useEffect5(() => {
+    return () => {
+      pendingChangesRef.current.forEach((pending_1) => {
+        if (pending_1.timeoutId) clearTimeout(pending_1.timeoutId);
+      });
+    };
+  }, []);
+  const saveCurrentValue = useCallback2(async () => {
+    if (currentId.current) {
+      await saveEntityChanges(currentId.current);
+    }
+  }, [saveEntityChanges]);
+  return [value, updateValue, upsertMutation, setValue, setNewEntity, saveCurrentValue];
+}
+
+// src/useToastError.ts
+import { c as _c14 } from "react/compiler-runtime";
+import { useEffect as useEffect6 } from "react";
+import { useToast } from "@pol-studios/hooks/toast";
+function useToastError(mutation) {
+  const $ = _c14(5);
+  const toast = useToast();
+  let t0;
+  if ($[0] !== mutation.error || $[1] !== toast) {
+    t0 = () => {
+      if (isUsable(mutation.error) === false) {
+        return;
+      }
+      toast.toast({
+        title: "Error",
+        description: mutation.error.message
+      });
+    };
+    $[0] = mutation.error;
+    $[1] = toast;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  let t1;
+  if ($[3] !== mutation.error) {
+    t1 = [mutation.error];
+    $[3] = mutation.error;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  useEffect6(t0, t1);
+  return mutation;
+}
+
+// src/advance-query.tsx
+async function executeAdvanceQuery(supabase, query, filterLayer) {
+  const parser = new PostgrestParser(query);
+  const filterGroup = {
+    id: filterLayer.id,
+    op: filterLayer.op,
+    not: filterLayer.not,
+    filters: filterLayer.filters.map(normalizeFilter).filter((f) => f !== null)
+  };
+  const pagination = {
+    offset: void 0,
+    limit: void 0
+  };
+  const sort = [...filterLayer.sort || []];
+  const searchParams = Array.from(parser.searchParams.entries());
+  searchParams.forEach(([k, v]) => {
+    if (k.includes("offset")) {
+      pagination.offset = Number(v);
+      return;
+    }
+    if (k.includes("limit")) {
+      pagination.limit = Number(v);
+      return;
+    }
+    if (k.includes("order")) {
+      const orderColumns = v.split(",");
+      orderColumns.forEach((x) => {
+        const values2 = x.split(".");
+        sort.push({
+          field: values2[0],
+          direction: values2[1] === "asc" ? "asc" : "desc"
+        });
+      });
+      return;
+    }
+    if (v.includes(".") === false) return;
+    const values = v.split(".");
+    const column = k;
+    const rawCondition = values[0];
+    let condition = "";
+    const value = values[1];
+    if (column == "select") return;
+    switch (rawCondition) {
+      case "eq":
+        condition = "=";
+        break;
+      case "in":
+        condition = "in";
+        break;
+      case "lt":
+        condition = "<";
+        break;
+      case "gt":
+        condition = ">";
+        break;
+      case "lte":
+        condition = "<=";
+        break;
+      case "gte":
+        condition = ">=";
+        break;
+      case "is":
+        condition = "is";
+        break;
+      case "ilike":
+        condition = "ilike";
+        break;
+      case "neq":
+        condition = "=";
+        break;
+      case "like":
+        condition = "contains";
+        break;
+    }
+    filterGroup.filters.push({
+      id: `filter_${column}_${Date.now()}`,
+      field: column,
+      op: condition,
+      value,
+      display: `${column} ${condition} ${value}`
+    });
+  });
+  const stripUIProperties = (obj) => {
+    return JSON.parse(JSON.stringify(obj, (key, value) => {
+      if (key === "display" || key === "info" || key === "options") {
+        return void 0;
+      }
+      return value;
+    }));
+  };
+  const cleanedBody = stripUIProperties({
+    table: parser.table,
+    schema: parser.schema,
+    select: parser.select,
+    filters: filterGroup,
+    pagination,
+    sort,
+    count: "exact"
+  });
+  const response = await supabase.functions.invoke("query", {
+    body: cleanedBody,
+    method: "POST"
+  });
+  if (response.error) {
+    return {
+      data: null,
+      count: null,
+      error: response.error
+    };
+  }
+  return {
+    data: response.data?.data ?? null,
+    count: response.data?.count ?? null,
+    error: null
+  };
+}
+
+// src/storage/useStorageUrl.ts
+var import_moment2 = __toESM(require_moment(), 1);
+import { useRef as useRef6 } from "react";
+import { useIndexedDB } from "@pol-studios/hooks/storage";
+var cacheVersions = /* @__PURE__ */ new Map();
+var cacheVersionListeners = /* @__PURE__ */ new Map();
+var retryAttempts = /* @__PURE__ */ new Map();
+function useStorageUrl() {
+  const db = useIndexedDB({
+    dbName: "polstudios",
+    storeName: "cached-urls"
+  });
+  const storedUrls = useRef6(/* @__PURE__ */ new Map());
+  const supabase = useSupabase();
+  function getCacheVersion(entity) {
+    const key = `${entity.bucketId}${entity.path}`;
+    return cacheVersions.get(key) || 0;
+  }
+  function subscribeToCacheVersion(entity_0, callback) {
+    const key_0 = `${entity_0.bucketId}${entity_0.path}`;
+    if (!cacheVersionListeners.has(key_0)) {
+      cacheVersionListeners.set(key_0, /* @__PURE__ */ new Set());
+    }
+    cacheVersionListeners.get(key_0).add(callback);
+    return () => {
+      cacheVersionListeners.get(key_0)?.delete(callback);
+    };
+  }
+  async function expireCache(entity_1) {
+    const key_1 = `${entity_1.bucketId}${entity_1.path}`;
+    const dbKeys = await db.getAllKeys();
+    const keysToDelete = Array.from(new Set([...Array.from(storedUrls.current.keys()), ...dbKeys].filter((value) => value.startsWith(key_1))));
+    await Promise.all(keysToDelete.map(async (x) => {
+      storedUrls.current.delete(x);
+      await db.removeItem(x);
+    }));
+    const currentVersion = cacheVersions.get(key_1) || 0;
+    cacheVersions.set(key_1, currentVersion + 1);
+    const listeners = cacheVersionListeners.get(key_1);
+    if (listeners) {
+      listeners.forEach((callback_0) => {
+        callback_0();
+      });
+    }
+  }
+  async function baseFetchUrl(entity_2, options, isPublic = false) {
+    if (isUsable(entity_2) === false) return;
+    const optionsString = JSON.stringify(options);
+    if (isUsable(entity_2.bucketId) === false) {
+      return;
+    }
+    if (isUsable(entity_2.path) === false) {
+      return;
+    }
+    const key_2 = `${entity_2.bucketId}${entity_2.path}${optionsString ?? ""}-cached-url`;
+    const inMemoryItem = storedUrls.current.get(key_2);
+    let item = inMemoryItem;
+    if (isUsable(inMemoryItem) === false) {
+      item = await db.getItem(key_2) ?? void 0;
+      if (isUsable(item)) {
+      }
+    } else {
+    }
+    if (isUsable(item) && (0, import_moment2.default)(item.expiresOn).isAfter((0, import_moment2.default)().add(-1 * 60, "seconds"))) {
+      return item.url;
+    }
+    const base = supabase.storage.from(entity_2.bucketId);
+    let download = options?.download;
+    if (typeof options?.download === "string") {
+      const ext = entity_2.path.split(".").pop() ?? "";
+      download = options?.download.endsWith(ext) ? options?.download : options?.download + "." + ext;
+    }
+    const newOptions = options ? {
+      ...options,
+      download
+    } : void 0;
+    const retryKey = `${entity_2.bucketId}/${entity_2.path}`;
+    const currentRetries = retryAttempts.get(retryKey) || 0;
+    let url;
+    if (isPublic) {
+      url = base.getPublicUrl(entity_2.path, newOptions).data.publicUrl;
+    } else {
+      try {
+        console.log("Creating signed URL for", entity_2.path);
+        const result = await base.createSignedUrl(entity_2.path, 60 * 100, newOptions);
+        url = result.data?.signedUrl;
+        if (isUsable(url)) {
+          retryAttempts.delete(retryKey);
+        } else if (currentRetries < 3) {
+          retryAttempts.set(retryKey, currentRetries + 1);
+          throw new Error("Failed to get signed URL");
+        }
+      } catch (error) {
+        if (currentRetries < 3) {
+          retryAttempts.set(retryKey, currentRetries + 1);
+          const delay = Math.min(1e3 * Math.pow(2, currentRetries), 5e3);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          return baseFetchUrl(entity_2, options, isPublic);
+        }
+        retryAttempts.delete(retryKey);
+        return void 0;
+      }
+    }
+    if (isUsable(url) === false) return url;
+    const cachedUrl = {
+      key: key_2,
+      url,
+      expiresOn: (0, import_moment2.default)().add(60 * 100, "seconds").toISOString(true)
+    };
+    storedUrls.current.set(key_2, cachedUrl);
+    db.setItem(key_2, cachedUrl);
+    return url;
+  }
+  async function fetchUrl(entity_3, options_0) {
+    return baseFetchUrl(entity_3, options_0, false);
+  }
+  async function fetchPublicUrl(entity_4, options_1) {
+    return baseFetchUrl(entity_4, options_1, true);
+  }
+  async function prefetchImage(entity_5, options_2) {
+    const url_0 = await fetchUrl(entity_5, options_2);
+    if (url_0) {
+      new Image().src = url_0;
+    }
+  }
+  async function fetchUrls(entities, options_3) {
+    const results = /* @__PURE__ */ new Map();
+    if (entities.length === 0) return results;
+    const optionsString_0 = JSON.stringify(options_3);
+    const expirySeconds = 60 * 100;
+    const byBucket = /* @__PURE__ */ new Map();
+    for (const entity_6 of entities) {
+      if (!isUsable(entity_6.bucketId) || !isUsable(entity_6.path)) continue;
+      const list = byBucket.get(entity_6.bucketId) ?? [];
+      list.push(entity_6);
+      byBucket.set(entity_6.bucketId, list);
+    }
+    for (const [bucketId, bucketEntities] of byBucket) {
+      const uncached = [];
+      for (const entity_7 of bucketEntities) {
+        const key_3 = `${entity_7.bucketId}${entity_7.path}${optionsString_0 ?? ""}-cached-url`;
+        const entityKey = `${entity_7.bucketId}/${entity_7.path}`;
+        let item_0 = storedUrls.current.get(key_3);
+        if (!isUsable(item_0)) {
+          item_0 = await db.getItem(key_3) ?? void 0;
+        }
+        if (isUsable(item_0) && (0, import_moment2.default)(item_0.expiresOn).isAfter((0, import_moment2.default)().add(-1 * 60, "seconds"))) {
+          results.set(entityKey, item_0.url);
+        } else {
+          uncached.push(entity_7);
+        }
+      }
+      if (uncached.length > 0) {
+        const paths = uncached.map((e) => e.path);
+        const base_0 = supabase.storage.from(bucketId);
+        try {
+          console.log("Signed URLs created");
+          const {
+            data,
+            error: error_0
+          } = await base_0.createSignedUrls(paths, expirySeconds);
+          if (!error_0 && data) {
+            const expiresOn = (0, import_moment2.default)().add(expirySeconds, "seconds").toISOString(true);
+            for (let i = 0; i < uncached.length; i++) {
+              const entity_9 = uncached[i];
+              const urlData = data[i];
+              const entityKey_1 = `${entity_9.bucketId}/${entity_9.path}`;
+              const cacheKey = `${entity_9.bucketId}${entity_9.path}${optionsString_0 ?? ""}-cached-url`;
+              if (urlData?.signedUrl) {
+                results.set(entityKey_1, urlData.signedUrl);
+                const cachedUrl_0 = {
+                  key: cacheKey,
+                  url: urlData.signedUrl,
+                  expiresOn
+                };
+                storedUrls.current.set(cacheKey, cachedUrl_0);
+                db.setItem(cacheKey, cachedUrl_0);
+              } else {
+                results.set(entityKey_1, void 0);
+              }
+            }
+          } else {
+            for (const entity_10 of uncached) {
+              const entityKey_2 = `${entity_10.bucketId}/${entity_10.path}`;
+              const url_2 = await fetchUrl(entity_10, options_3);
+              results.set(entityKey_2, url_2);
+            }
+          }
+        } catch {
+          for (const entity_8 of uncached) {
+            const entityKey_0 = `${entity_8.bucketId}/${entity_8.path}`;
+            const url_1 = await fetchUrl(entity_8, options_3);
+            results.set(entityKey_0, url_1);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  return {
+    fetchUrl,
+    fetchUrls,
+    prefetchImage,
+    fetchPublicUrl,
+    expireCache,
+    getCacheVersion,
+    subscribeToCacheVersion
+  };
+}
+
+// src/storage/useStoragePath.ts
+import { c as _c15 } from "react/compiler-runtime";
+import { useEffect as useEffect7, useState as useState6 } from "react";
+function getContentType(metadata, path) {
+  if (metadata?.contentType) {
+    return metadata.contentType;
+  }
+  const ext = path.split(".").pop()?.toUpperCase();
+  return ext || "Unknown";
+}
+function useStoragePath(storagePath, bucketId, t0) {
+  const $ = _c15(40);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const options = t1;
+  const {
+    fetchMetadata: t2,
+    transform,
+    download
+  } = options;
+  const fetchMetadata = t2 === void 0 ? true : t2;
+  const [url, setUrl] = useState6(null);
+  const [error, setError] = useState6(null);
+  const {
+    fetchUrl
+  } = useStorageUrl();
+  const supabase = useSupabase();
+  let t3;
+  if ($[2] !== bucketId || $[3] !== download || $[4] !== fetchUrl || $[5] !== storagePath || $[6] !== transform) {
+    t3 = () => {
+      if (!isUsable(storagePath) || !isUsable(bucketId)) {
+        setUrl(null);
+        return;
+      }
+      let cancelled = false;
+      fetchUrl({
+        bucketId,
+        path: storagePath
+      }, {
+        transform,
+        download
+      }).then((signedUrl) => {
+        if (!cancelled) {
+          setUrl(signedUrl ?? null);
+          setError(null);
+        }
+      }).catch((err) => {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+          setUrl(null);
+        }
+      });
+      return () => {
+        cancelled = true;
+      };
+    };
+    $[2] = bucketId;
+    $[3] = download;
+    $[4] = fetchUrl;
+    $[5] = storagePath;
+    $[6] = transform;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  let t4;
+  if ($[8] !== transform) {
+    t4 = JSON.stringify(transform);
+    $[8] = transform;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] !== bucketId || $[11] !== download || $[12] !== storagePath || $[13] !== t4) {
+    t5 = [storagePath, bucketId, t4, download];
+    $[10] = bucketId;
+    $[11] = download;
+    $[12] = storagePath;
+    $[13] = t4;
+    $[14] = t5;
+  } else {
+    t5 = $[14];
+  }
+  useEffect7(t3, t5);
+  let t6;
+  if ($[15] !== bucketId || $[16] !== storagePath || $[17] !== supabase) {
+    t6 = supabase.schema("storage").from("objects").select("metadata").eq("bucket_id", bucketId).eq("name", storagePath ?? "").maybeSingle();
+    $[15] = bucketId;
+    $[16] = storagePath;
+    $[17] = supabase;
+    $[18] = t6;
+  } else {
+    t6 = $[18];
+  }
+  const storageQuery = t6;
+  let t7;
+  if ($[19] !== bucketId || $[20] !== fetchMetadata || $[21] !== storagePath) {
+    t7 = fetchMetadata && isUsable(storagePath) && isUsable(bucketId);
+    $[19] = bucketId;
+    $[20] = fetchMetadata;
+    $[21] = storagePath;
+    $[22] = t7;
+  } else {
+    t7 = $[22];
+  }
+  let t8;
+  if ($[23] !== t7) {
+    t8 = {
+      enabled: t7
+    };
+    $[23] = t7;
+    $[24] = t8;
+  } else {
+    t8 = $[24];
+  }
+  const metadataRequest = useDbQuery(storageQuery, t8);
+  const metadata = metadataRequest.data?.metadata ?? null;
+  const t9 = storagePath ?? "";
+  let t10;
+  if ($[25] !== metadata || $[26] !== t9) {
+    t10 = getContentType(metadata, t9);
+    $[25] = metadata;
+    $[26] = t9;
+    $[27] = t10;
+  } else {
+    t10 = $[27];
+  }
+  const contentType = t10;
+  let t11;
+  if ($[28] !== error || $[29] !== fetchMetadata || $[30] !== metadataRequest.isFetching || $[31] !== storagePath || $[32] !== url) {
+    t11 = isUsable(storagePath) && url === null && error === null || fetchMetadata && metadataRequest.isFetching;
+    $[28] = error;
+    $[29] = fetchMetadata;
+    $[30] = metadataRequest.isFetching;
+    $[31] = storagePath;
+    $[32] = url;
+    $[33] = t11;
+  } else {
+    t11 = $[33];
+  }
+  const isLoading = t11;
+  let t12;
+  if ($[34] !== contentType || $[35] !== error || $[36] !== isLoading || $[37] !== metadata || $[38] !== url) {
+    t12 = {
+      url,
+      metadata,
+      contentType,
+      isLoading,
+      error
+    };
+    $[34] = contentType;
+    $[35] = error;
+    $[36] = isLoading;
+    $[37] = metadata;
+    $[38] = url;
+    $[39] = t12;
+  } else {
+    t12 = $[39];
+  }
+  return t12;
+}
+
+// src/storage/bucketConfig.ts
+var BUCKETS = {
+  AVATARS: "avatars",
+  FIXTURE_CATALOG_COVER: "fixture-catalog-cover",
+  FIXTURE_ATTACHMENTS: "fixture-attachments",
+  UNIT_DOCUMENTATION: "unit-documentation-attachments",
+  DATASHEETS: "datasheets",
+  PATTERNS: "patterns",
+  LOGOS: "logos",
+  RECEIPTS: "receipts",
+  TICKET_ATTACHMENTS: "ticket-attachment",
+  PROCESS_RESULTS: "process-results",
+  DATA_EXCHANGE_IMPORTS: "data-exchange-imports",
+  EMAIL_TEMPLATES: "email-templates",
+  EMAIL_TEMPLATES_ASSETS: "email-templates-assets"
+};
+
+// src/utilities/query-utils.ts
+function createInCondition(column, values) {
+  let condition = "";
+  if (values.length > 2e3) {
+    throw new Error("Too many values to create in condition");
+  }
+  chunkArray(values, 99).forEach((x, index) => {
+    if (index == 0) {
+      condition = `${column}.in.(${x.join(",")})`;
+      return;
+    }
+    condition += `,${column}.in.(${x.join(",")})`;
+  });
+  return condition;
+}
+
+// src/changelog/useChangelogMutations.ts
+import { c as _c16 } from "react/compiler-runtime";
+var useUpsertChangelog = () => {
+  const $ = _c16(1);
+  let t0;
+  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      invalidateTables: ["Changelog", "ChangelogEntry", "ChangelogMedia"]
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return useDbUpsert("Changelog", t0);
+};
+var useDeleteChangelog = () => {
+  return useDbDelete("Changelog");
+};
+var useUpsertChangelogEntry = () => {
+  const $ = _c16(1);
+  let t0;
+  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      invalidateTables: ["ChangelogEntry", "ChangelogMedia"]
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return useDbUpsert("ChangelogEntry", t0);
+};
+var useMultiUpsertChangelogEntries = () => {
+  const $ = _c16(1);
+  let t0;
+  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t0 = ["id"];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return useDbMultiUpsert("ChangelogEntry", t0, "*, ChangelogMedia (*)");
+};
+var useDeleteChangelogEntry = () => {
+  return useDbDelete("ChangelogEntry");
+};
+var useMultiDeleteChangelogEntries = () => {
+  return useDbMultiDelete("ChangelogEntry");
+};
+var useUpsertChangelogMedia = () => {
+  const $ = _c16(1);
+  let t0;
+  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      invalidateTables: ["ChangelogMedia"]
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return useDbUpsert("ChangelogMedia", t0);
+};
+var useDeleteChangelogMedia = () => {
+  return useDbDelete("ChangelogMedia");
+};
+var useUploadChangelogMedia = () => {
+  return {
+    mutateAsync: async () => ({
+      path: "",
+      publicUrl: ""
+    })
+  };
+};
+
+// src/changelog/useChangelogQuery.ts
+import { c as _c17 } from "react/compiler-runtime";
+var useChangelogs = (options) => {
+  const supabase = useSupabase();
+  const query = supabase.from("Changelog").select(`
+      *,
+      ChangelogEntry (
+        *,
+        ChangelogMedia (*)
+      )
+    `).order("releaseDate", {
+    ascending: false
+  }).order("order", {
+    foreignTable: "ChangelogEntry",
+    ascending: true
+  }).order("order", {
+    foreignTable: "ChangelogEntry.ChangelogMedia",
+    ascending: true
+  });
+  if (options?.realtime) {
+    return useDbRealtimeQuery(query, {
+      crossOrganization: true
+    });
+  }
+  return useDbQuery(query, {
+    crossOrganization: true
+  });
+};
+var usePublishedChangelogs = (options) => {
+  const supabase = useSupabase();
+  const query = supabase.from("Changelog").select(`
+      *,
+      ChangelogEntry (
+        *,
+        ChangelogMedia (*)
+      )
+    `).eq("isPublished", true).order("releaseDate", {
+    ascending: false
+  }).order("order", {
+    foreignTable: "ChangelogEntry",
+    ascending: true
+  }).order("order", {
+    foreignTable: "ChangelogEntry.ChangelogMedia",
+    ascending: true
+  });
+  if (options?.realtime) {
+    return useDbRealtimeQuery(query, {
+      crossOrganization: true
+    });
+  }
+  return useDbQuery(query, {
+    crossOrganization: true
+  });
+};
+var useChangelogById = (id) => {
+  const $ = _c17(5);
+  const supabase = useSupabase();
+  let t0;
+  if ($[0] !== id || $[1] !== supabase) {
+    t0 = supabase.from("Changelog").select("\n        *,\n        ChangelogEntry (\n          *,\n          ChangelogMedia (*)\n        )\n      ").eq("id", id).order("order", {
+      foreignTable: "ChangelogEntry",
+      ascending: true
+    }).order("order", {
+      foreignTable: "ChangelogEntry.ChangelogMedia",
+      ascending: true
+    }).single();
+    $[0] = id;
+    $[1] = supabase;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const t1 = !!id;
+  let t2;
+  if ($[3] !== t1) {
+    t2 = {
+      enabled: t1,
+      crossOrganization: true
+    };
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return useDbQuery(t0, t2);
+};
+var useChangelogBySlug = (slug) => {
+  const $ = _c17(5);
+  const supabase = useSupabase();
+  let t0;
+  if ($[0] !== slug || $[1] !== supabase) {
+    t0 = supabase.from("Changelog").select("\n        *,\n        ChangelogEntry (\n          *,\n          ChangelogMedia (*)\n        )\n      ").eq("slug", slug).order("order", {
+      foreignTable: "ChangelogEntry",
+      ascending: true
+    }).order("order", {
+      foreignTable: "ChangelogEntry.ChangelogMedia",
+      ascending: true
+    }).single();
+    $[0] = slug;
+    $[1] = supabase;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const t1 = !!slug;
+  let t2;
+  if ($[3] !== t1) {
+    t2 = {
+      enabled: t1,
+      crossOrganization: true
+    };
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return useDbQuery(t0, t2);
+};
+var useChangelogEntries = (changelogId) => {
+  const $ = _c17(5);
+  const supabase = useSupabase();
+  let t0;
+  if ($[0] !== changelogId || $[1] !== supabase) {
+    t0 = supabase.from("ChangelogEntry").select("*, ChangelogMedia (*)").eq("changelogId", changelogId).order("order", {
+      ascending: true
+    }).order("order", {
+      foreignTable: "ChangelogMedia",
+      ascending: true
+    });
+    $[0] = changelogId;
+    $[1] = supabase;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const t1 = !!changelogId;
+  let t2;
+  if ($[3] !== t1) {
+    t2 = {
+      enabled: t1,
+      crossOrganization: true
+    };
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return useDbQuery(t0, t2);
+};
+var useChangelogMedia = (entryId) => {
+  const $ = _c17(5);
+  const supabase = useSupabase();
+  let t0;
+  if ($[0] !== entryId || $[1] !== supabase) {
+    t0 = supabase.from("ChangelogMedia").select("*").eq("changelogEntryId", entryId).order("order", {
+      ascending: true
+    });
+    $[0] = entryId;
+    $[1] = supabase;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const t1 = !!entryId;
+  let t2;
+  if ($[3] !== t1) {
+    t2 = {
+      enabled: t1,
+      crossOrganization: true
+    };
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return useDbQuery(t0, t2);
+};
+
+// src/nl-training/useFeedbackList.ts
+import { c as _c18 } from "react/compiler-runtime";
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useFeedbackList(t0) {
+  const $ = _c18(10);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const params = t1;
+  const supabase = useSupabase();
+  let t2;
+  if ($[2] !== params) {
+    t2 = ["feedback-list", params];
+    $[2] = params;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  let t3;
+  if ($[4] !== params || $[5] !== supabase) {
+    t3 = async () => {
+      const searchParams = new URLSearchParams();
+      if (params.resolved !== void 0) {
+        searchParams.append("resolved", String(params.resolved));
+      }
+      if (params.status) {
+        searchParams.append("status", params.status);
+      }
+      if (params.limit) {
+        searchParams.append("limit", String(params.limit));
+      }
+      if (params.offset) {
+        searchParams.append("offset", String(params.offset));
+      }
+      if (params.userId) {
+        searchParams.append("userId", params.userId);
+      }
+      if (params.startDate) {
+        searchParams.append("startDate", params.startDate);
+      }
+      if (params.endDate) {
+        searchParams.append("endDate", params.endDate);
+      }
+      const {
+        data,
+        error
+      } = await supabase.functions.invoke("query", {
+        body: {},
+        method: "GET",
+        headers: {
+          "X-Path": `/query/feedback?${searchParams.toString()}`
+        }
+      });
+      if (error) {
+        throw error;
+      }
+      return data;
+    };
+    $[4] = params;
+    $[5] = supabase;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== t2 || $[8] !== t3) {
+    t4 = {
+      queryKey: t2,
+      queryFn: t3
+    };
+    $[7] = t2;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  return useQuery2(t4);
+}
+
+// src/nl-training/useSubmitFeedback.ts
+import { c as _c19 } from "react/compiler-runtime";
+import { useMutation as useMutation6, useQueryClient } from "@tanstack/react-query";
+function useSubmitFeedback() {
+  const $ = _c19(7);
+  const supabase = useSupabase();
+  const queryClient = useQueryClient();
+  let t0;
+  if ($[0] !== supabase) {
+    t0 = async (params) => {
+      const {
+        data,
+        error
+      } = await supabase.functions.invoke("query", {
+        body: params,
+        method: "POST",
+        headers: {
+          "X-Path": "/query/feedback"
+        }
+      });
+      if (error) {
+        throw error;
+      }
+      return data;
+    };
+    $[0] = supabase;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== queryClient) {
+    t1 = () => {
+      queryClient.invalidateQueries({
+        queryKey: ["feedback-list"]
+      });
+    };
+    $[2] = queryClient;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  let t2;
+  if ($[4] !== t0 || $[5] !== t1) {
+    t2 = {
+      mutationFn: t0,
+      onSuccess: t1
+    };
+    $[4] = t0;
+    $[5] = t1;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  return useMutation6(t2);
+}
+
+// src/nl-training/useApplyFeedback.ts
+import { c as _c20 } from "react/compiler-runtime";
+import { useMutation as useMutation7, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+function useApplyFeedback() {
+  const $ = _c20(7);
+  const supabase = useSupabase();
+  const queryClient = useQueryClient2();
+  let t0;
+  if ($[0] !== supabase) {
+    t0 = async (memoryId) => {
+      const {
+        data,
+        error
+      } = await supabase.functions.invoke("query", {
+        body: {},
+        method: "POST",
+        headers: {
+          "X-Path": `/query/feedback/${memoryId}/apply`
+        }
+      });
+      if (error) {
+        throw error;
+      }
+      return data;
+    };
+    $[0] = supabase;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== queryClient) {
+    t1 = () => {
+      queryClient.invalidateQueries({
+        queryKey: ["feedback-list"]
+      });
+    };
+    $[2] = queryClient;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  let t2;
+  if ($[4] !== t0 || $[5] !== t1) {
+    t2 = {
+      mutationFn: t0,
+      onSuccess: t1
+    };
+    $[4] = t0;
+    $[5] = t1;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  return useMutation7(t2);
+}
+
+// src/nl-training/useResolveFeedback.ts
+import { c as _c21 } from "react/compiler-runtime";
+import { useMutation as useMutation8, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+function useResolveFeedback() {
+  const $ = _c21(7);
+  const supabase = useSupabase();
+  const queryClient = useQueryClient3();
+  let t0;
+  if ($[0] !== supabase) {
+    t0 = async (memoryId) => {
+      const {
+        data,
+        error
+      } = await supabase.functions.invoke("query", {
+        body: {},
+        method: "POST",
+        headers: {
+          "X-Path": `/query/feedback/${memoryId}/resolve`
+        }
+      });
+      if (error) {
+        throw error;
+      }
+      return data;
+    };
+    $[0] = supabase;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== queryClient) {
+    t1 = () => {
+      queryClient.invalidateQueries({
+        queryKey: ["feedback-list"]
+      });
+    };
+    $[2] = queryClient;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  let t2;
+  if ($[4] !== t0 || $[5] !== t1) {
+    t2 = {
+      mutationFn: t0,
+      onSuccess: t1
+    };
+    $[4] = t0;
+    $[5] = t1;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  return useMutation8(t2);
+}
+
+export {
+  useDbDelete,
+  useDbInfiniteQuery,
+  useDbInsert,
+  useDbMultiDelete,
+  useDbMultiUpsert,
+  useDbPartialAdvanceQuery,
+  useDbPartialQuery,
+  useDbRealtime,
+  convertFilterToRealtimeQuery,
+  useDbRealtimeQuery,
+  useDbUpdate,
+  useMutationSuccess,
+  useMutationSuccessRN,
+  ADAPTER_STRATEGIES,
+  BackendStatus,
+  AdapterAutoDetector,
+  createAdapterAutoDetector,
+  AdapterRegistry,
+  createAdapterRegistry,
+  SupabaseAdapter,
+  createSupabaseAdapter,
+  getErrorBody,
+  useAI,
+  useServerAvailability,
+  useSearchQuery,
+  useLiveChangeTracking,
+  useLatestOperationLog,
+  newTimeActivity,
+  useAutosaveState,
+  useToastError,
+  executeAdvanceQuery,
+  useStorageUrl,
+  useStoragePath,
+  BUCKETS,
+  createInCondition,
+  useUpsertChangelog,
+  useDeleteChangelog,
+  useUpsertChangelogEntry,
+  useMultiUpsertChangelogEntries,
+  useDeleteChangelogEntry,
+  useMultiDeleteChangelogEntries,
+  useUpsertChangelogMedia,
+  useDeleteChangelogMedia,
+  useUploadChangelogMedia,
+  useChangelogs,
+  usePublishedChangelogs,
+  useChangelogById,
+  useChangelogBySlug,
+  useChangelogEntries,
+  useChangelogMedia,
+  useFeedbackList,
+  useSubmitFeedback,
+  useApplyFeedback,
+  useResolveFeedback
+};
+//# sourceMappingURL=chunk-NZON56CB.js.map