@pol-studios/db 1.0.31 → 1.0.34

package/dist/{useDbCount-Dk0yCKlT.d.ts → useDbCount-DWfYB2iu.d.ts}

@@ -1,4 +1,4 @@
-import { p as DataLayerContextValue, q as DataLayerCoreContextValue, r as DataLayerStatusContextValue } from './DataLayerContext-Dc7nF2IG.js';
+import { r as DataLayerContextValue, s as DataLayerCoreContextValue, t as DataLayerStatusContextValue } from './DataLayerContext-BwMk4VpG.js';
 import { Dispatch, SetStateAction } from 'react';
 import { QueryOptions, WhereClause } from './core/index.js';
 
@@ -40,6 +40,20 @@ import { QueryOptions, WhereClause } from './core/index.js';
  * // This component won't re-render on sync status changes
  */
 declare function useDataLayerCore(): DataLayerCoreContextValue;
+/**
+ * Hook to access ONLY the STABLE core context (optional version).
+ * Returns null if DataLayerProvider is not present, rather than throwing.
+ * Use this when you need graceful fallback behavior.
+ *
+ * @example
+ * const dataLayerCore = useDataLayerCoreOptional();
+ * if (dataLayerCore) {
+ *   // Use V3 adapter pattern
+ * } else {
+ *   // Fall back to Supabase
+ * }
+ */
+declare function useDataLayerCoreOptional(): DataLayerCoreContextValue | null;
 /**
  * Hook to access ONLY the dynamic status values
  *
@@ -1079,4 +1093,4 @@ interface UseDbCountResult {
  */
 declare function useDbCount(table: string, options?: UseDbCountOptions): UseDbCountResult;
 
-export { type Sort as A, type UseDbInsertOptions as B, type ClarificationQuestion as C, type DatabaseTypes$1 as D, type UseDbInsertResult as E, type Filter as F, type UseDbUpdateOptions as G, type UseDbUpdateResult as H, type UseDbUpsertOptions as I, type UseDbUpsertResult as J, type UseDbDeleteOptions as K, type UseDbDeleteResult as L, type PublicTableNames$1 as P, type QueryState as Q, type ResolveRowType$1 as R, type SchemaNames$1 as S, type TableIdentifier$1 as T, type UseAdvanceQueryOptions as U, useDataLayer as a, useDataLayerCore as b, useDataLayerStatus as c, useDbCount as d, useDbDelete as e, useDbInfiniteQuery as f, useDbInsert as g, useDbQuery as h, useDbQueryById as i, useDbUpdate as j, useDbUpsert as k, type SchemaTableNames$1 as l, type UseAdvanceQueryResult as m, type UseDbCountOptions as n, type UseDbCountResult as o, type UseDbInfiniteQueryOptions as p, type UseDbInfiniteQueryResult as q, type UseDbQueryOptions as r, type UseDbQueryResult as s, useDataLayerOptional as t, useAdvanceQuery as u, type UseDbQueryByIdOptions as v, type UseDbQueryByIdResult as w, type FilterGroup as x, type FilterOperator as y, type Pagination as z };
+export { type Sort as A, type UseDbInsertOptions as B, type ClarificationQuestion as C, type DatabaseTypes$1 as D, type UseDbInsertResult as E, type Filter as F, type UseDbUpdateOptions as G, type UseDbUpdateResult as H, type UseDbUpsertOptions as I, type UseDbUpsertResult as J, type UseDbDeleteOptions as K, type UseDbDeleteResult as L, useDataLayerCoreOptional as M, type PublicTableNames$1 as P, type QueryState as Q, type ResolveRowType$1 as R, type SchemaNames$1 as S, type TableIdentifier$1 as T, type UseAdvanceQueryOptions as U, useDataLayer as a, useDataLayerCore as b, useDataLayerOptional as c, useDataLayerStatus as d, useDbCount as e, useDbDelete as f, useDbInfiniteQuery as g, useDbInsert as h, useDbQuery as i, useDbQueryById as j, useDbUpdate as k, useDbUpsert as l, type SchemaTableNames$1 as m, type UseAdvanceQueryResult as n, type UseDbCountOptions as o, type UseDbCountResult as p, type UseDbInfiniteQueryOptions as q, type UseDbInfiniteQueryResult as r, type UseDbQueryOptions as s, type UseDbQueryResult as t, useAdvanceQuery as u, type UseDbQueryByIdOptions as v, type UseDbQueryByIdResult as w, type FilterGroup as x, type FilterOperator as y, type Pagination as z };

package/dist/{useResolveFeedback-C1KucfdQ.d.ts → useResolveFeedback-CxLccZKK.d.ts}

@@ -1,22 +1,23 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { UseMutationResult, UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
 import { SupabaseClient, PostgrestSingleResponse as PostgrestSingleResponse$1, PostgrestError } from '@supabase/supabase-js';
-import { T as TableDataAdapter, C as CapableDataAdapter, c as AdapterCapabilities, A as AdapterQueryResult } from './DataLayerContext-Dc7nF2IG.js';
+import { T as TableDataAdapter, C as CapableDataAdapter, c as AdapterCapabilities, A as AdapterQueryResult } from './DataLayerContext-BwMk4VpG.js';
 import { DatabaseSchema, QueryOptions } from './core/index.js';
 import { FunctionsResponse } from '@supabase/functions-js';
 import * as _supabase_postgrest_js from '@supabase/postgrest-js';
 import { PostgrestSingleResponse } from '@supabase/postgrest-js';
 import { G as GetResult } from './select-query-parser-BwyHum1L.js';
 import { G as GenericTable } from './types-CYr9JiUE.js';
-import { D as Database } from './useSupabase-DvWVuHHE.js';
-import { D as DbChangeLog, Q as QueryState } from './index-CYFdO0iB.js';
+import { D as Database } from './useSupabase-DSZNeXnF.js';
+import { D as DbChangeLog, Q as QueryState } from './index-lveh8qb0.js';
 import { U as UseDbQuerySingleReturn } from './useDbQuery-C-TL8jY1.js';
-import { J as UseDbUpsertResult } from './useDbCount-Dk0yCKlT.js';
+import { J as UseDbUpsertResult } from './useDbCount-DWfYB2iu.js';
 import { Moment } from 'moment';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { TransformOptions } from '@supabase/storage-js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import { TransformOptions } from '@supabase/storage-js';
+import { ItemType } from '@pol-studios/utils';
 
 declare function setSupabaseUrl(url: string): void;
 declare function getSupabaseUrl(): string;
@@ -81,6 +82,11 @@ declare class SupabaseAdapter implements TableDataAdapter, CapableDataAdapter {
      * @returns Object with schema (defaults to "public") and tableName
      */
     private parseTableIdentifier;
+    /**
+     * Check if a where clause contains invalid UUID values (empty strings for id fields).
+     * Returns true if any id field has an empty string value.
+     */
+    private hasInvalidUuidFilter;
     /**
      * Execute a query and return results with optional count
      *
@@ -118,6 +124,10 @@ declare class SupabaseAdapter implements TableDataAdapter, CapableDataAdapter {
     /**
      * Upsert (insert or update) a record
      *
+     * When the data has an ID, tries UPDATE first to support partial updates
+     * (which may not include all NOT NULL columns). Falls back to INSERT
+     * if no rows were updated.
+     *
      * @param table - The table name
      * @param data - The data to upsert
      * @returns Promise resolving to the upserted record
@@ -280,9 +290,69 @@ declare function useAutosaveState<T extends TItem & {
     UseDbUpsertResult<T>,
     React.Dispatch<React.SetStateAction<T>>,
     (newEntity: T) => void,
-    () => Promise<void>
+    () => Promise<void>,
+    T,
+    (newBase: T) => void
 ];
 
+/**
+ * useAutosave Hook v2.0
+ *
+ * A simple, robust autosave hook for PowerSync offline-first apps.
+ *
+ * Key design principles:
+ * 1. PowerSync SQLite is the single source of truth
+ * 2. Dirty buffer (ref) accumulates field-level patches - no complex state
+ * 3. Reconciliation: when watched value matches dirty value, clear entry
+ * 4. Entity switching: flush old entity immediately, new entity starts fresh
+ * 5. No baseValue tracking - watchedData IS the base
+ *
+ * @example
+ * ```tsx
+ * const { data } = useDbQuery("Task", { where: { id: taskId }, realtime: true });
+ *
+ * const { value, patch, isSaving } = useAutosave(
+ *   "Task",
+ *   taskId,
+ *   data?.[0] ?? null,
+ *   { delay: 2000 }
+ * );
+ *
+ * <TextInput value={value?.title} onChangeText={t => patch({ title: t })} />
+ * ```
+ */
+interface UseAutosaveOptions {
+    /** Debounce delay in ms before saving (default: 2000) */
+    delay?: number;
+}
+interface UseAutosaveResult<T> {
+    /** The merged value: dirty fields overlaid on watchedData */
+    value: T | null;
+    /** Update one or more fields. Starts the debounce timer. */
+    patch: (updates: Partial<T>) => void;
+    /** Force-flush any pending changes immediately */
+    flush: () => Promise<void>;
+    /** Re-trigger save after error, no user edit required */
+    retry: () => void;
+    /** True while save is in-flight for current entity */
+    isSaving: boolean;
+    /** Last error from save attempt */
+    saveError: Error | null;
+    /** Clear the error without triggering save */
+    clearError: () => void;
+}
+/**
+ * Autosave hook that manages optimistic local edits with debounced persistence.
+ *
+ * @param table - The table name to save to
+ * @param entityId - The entity ID (null = hook is inert)
+ * @param watchedData - Live data from useDbQuery with realtime:true
+ * @param options - Configuration options
+ */
+declare function useAutosave<T extends {
+    id: string;
+}>(table: string, entityId: string | null, watchedData: T | null, options?: UseAutosaveOptions): UseAutosaveResult<T>;
+
 declare function useToastError<T>(mutation: UseDbUpsertResult<T>): UseDbUpsertResult<T>;
 
 declare function executeAdvanceQuery<Result>(supabase: any, query: PromiseLike<PostgrestSingleResponse$1<Result>>, filterLayer: QueryState): Promise<{
@@ -542,103 +612,89 @@ declare function useDbPartialQuery<Result extends Record<string, any>[]>(query:
 
 type CustomPageQueryResult<T extends Record<string, any>[]> = ReturnType<typeof useDbPartialQuery<T>>;
 
-type Attachment = {
-    bucketId: string;
-    path: string;
-};
-declare function useStorageUrl(): {
-    fetchUrl: (entity: {
-        bucketId: string;
-        path: string;
-    }, options?: {
-        download?: string | boolean;
-        transform?: TransformOptions;
-    }) => Promise<string>;
-    fetchUrls: (entities: Attachment[], options?: {
-        download?: string | boolean;
-        transform?: TransformOptions;
-    }) => Promise<Map<string, string | undefined>>;
-    prefetchImage: (entity: Attachment, options?: {
-        download?: string | boolean;
-        transform?: TransformOptions;
-    }) => Promise<void>;
-    fetchPublicUrl: (entity: {
-        bucketId: string;
-        path: string;
-    }, options?: {
-        download?: string | boolean;
-        transform?: TransformOptions;
-    }) => Promise<string>;
-    expireCache: (entity: {
-        bucketId: string;
-        path: string;
-    }) => Promise<void>;
-    getCacheVersion: (entity: {
-        bucketId: string;
-        path: string;
-    }) => number;
-    subscribeToCacheVersion: (entity: {
-        bucketId: string;
-        path: string;
-    }, callback: () => void) => () => void;
-};
-
 /**
- * Metadata stored in storage.objects.metadata JSONB column
+ * Async attachment queue provider for PowerSync integration.
+ * Used for async-first local lookups.
  */
-interface StorageObjectMetadata {
-    processingStatus: "None" | "Processing" | "Error";
-    contentType: string;
-    contentHeight?: number;
-    contentWidth?: number;
-    originalFileName?: string;
-    legacyAttachmentId?: number;
+interface AttachmentQueueProvider {
+    /** Get local file URI for a storage path asynchronously, or null if not cached */
+    getLocalUriForStoragePath: (storagePath: string) => Promise<string | null>;
+    /**
+     * Subscribe to cache/download progress updates. Returns cleanup function.
+     *
+     * Note: Callback uses `...args: unknown[]` for structural compatibility with
+     * PolAttachmentQueue.onProgress which passes stats. This package doesn't need
+     * the stats, so we accept any args to avoid importing PowerSync types.
+     */
+    onProgress?: (callback: (...args: unknown[]) => void) => () => void;
 }
-type UseStoragePathOptions = {
-    /** Whether to fetch metadata from storage.objects (default: true) */
-    fetchMetadata?: boolean;
-    /** Transform options for the URL */
-    transform?: {
-        width?: number;
-        height?: number;
-        quality?: number;
-        format?: "origin";
-    };
-    /** Whether to get a download URL */
-    download?: string | boolean;
-};
-type UseStoragePathResult = {
-    /** Signed URL for the storage object */
-    url: string | null;
-    /** Metadata from storage.objects.metadata JSONB */
-    metadata: StorageObjectMetadata | null;
-    /** Content type (from metadata or inferred from path) */
-    contentType: string;
-    /** Whether the URL or metadata is still loading */
+interface UseStorageSourceOptions {
+    /** Storage bucket ID (defaults to UNIT_DOCUMENTATION) */
+    bucketId?: string;
+    /** Whether to enable the hook (defaults to true) */
+    enabled?: boolean;
+    /** Image transform options for Supabase */
+    transform?: TransformOptions;
+    /**
+     * PowerSync attachment queue for async local-first caching.
+     */
+    attachmentQueue?: AttachmentQueueProvider | null;
+    /** Use public URL instead of signed URL (defaults to false) */
+    usePublicUrl?: boolean;
+}
+interface UseStorageSourceResult {
+    /** Resolved URI (local file:// or remote signed URL) */
+    uri: string | null;
+    /** Whether the URI is currently being fetched */
     isLoading: boolean;
-    /** Error if URL fetch failed */
+    /** Whether the URI is from local cache */
+    isLocal: boolean;
+    /** Error if fetching failed */
     error: Error | null;
-};
+    /** Force refresh the URI */
+    refresh: () => void;
+    /** Imperatively fetch a signed URL for any path (checks local cache first) */
+    getSignedUrl: (path: string, options?: {
+        transform?: TransformOptions;
+    }) => Promise<string | null>;
+    /** Clear local state and trigger a refresh */
+    invalidate: () => void;
+}
 /**
- * Hook to get a signed URL and metadata for a storage path.
- * Replaces useAttachment for the path-based storage approach.
+ * Standalone utility for fetching storage URLs outside React components.
+ * Does not check local cache - use for server-side or non-React contexts.
+ * Includes session refresh retry logic for auth errors.
+ */
+declare function getStorageUrl(supabase: SupabaseClient, storagePath: string, options?: {
+    bucketId?: string;
+    transform?: TransformOptions;
+    usePublicUrl?: boolean;
+}): Promise<string | null>;
+/**
+ * Unified hook for resolving storage URLs with optional local-first caching.
  *
- * @param storagePath - The path within the bucket (e.g., "14/abc-123.jpg")
- * @param bucketId - The storage bucket ID
- * @param options - Optional configuration
+ * Works on both web and React Native:
+ * - On web (no attachmentQueue): Fetches Supabase signed URLs directly
+ * - On RN with PowerSync: Checks local attachment cache first, falls back to signed URLs
  *
  * @example
- * ```tsx
- * const { url, contentType, isLoading } = useStoragePath(
- *   profile.profilePath,
- *   'attachments'
- * );
+ * // Basic usage (web or RN without local cache)
+ * const { uri, isLoading } = useStorageSource(photo.storage_path);
  *
- * if (isLoading) return <Spinner />;
- * return <img src={url} />;
- * ```
+ * @example
+ * // With PowerSync attachment queue (RN)
+ * const attachmentQueue = useAttachmentQueue();
+ * const { uri, isLocal } = useStorageSource(photo.storage_path, {
+ *   attachmentQueue,
+ * });
+ *
+ * @example
+ * // With transform options
+ * const { uri } = useStorageSource(photo.storage_path, {
+ *   transform: { width: 200, height: 200, resize: 'contain' },
+ * });
  */
-declare function useStoragePath(storagePath: string | undefined | null, bucketId: string, options?: UseStoragePathOptions): UseStoragePathResult;
+declare function useStorageSource(storagePath: string | null | undefined, options?: UseStorageSourceOptions): UseStorageSourceResult;
 
 /**
  * Storage bucket names for Supabase storage.
@@ -661,12 +717,60 @@ declare const BUCKETS: {
 };
 type BucketName = (typeof BUCKETS)[keyof typeof BUCKETS];
 
+interface StorageQueueProviderProps {
+    children: ReactNode;
+    /** The attachment queue instance (from @pol/powersync or any conforming implementation) */
+    attachmentQueue: AttachmentQueueProvider | null;
+    /** Whether the queue has finished its async init */
+    isReady: boolean;
+}
+declare function StorageQueueProvider({ children, attachmentQueue, isReady, }: StorageQueueProviderProps): react_jsx_runtime.JSX.Element;
+
+interface StorageQueueContextValue {
+    /** The attachment queue provider, or null if not available */
+    attachmentQueue: AttachmentQueueProvider | null;
+    /** Whether the queue has finished initializing (cold start guard) */
+    isReady: boolean;
+}
+declare const StorageQueueContext: react.Context<StorageQueueContextValue>;
+/**
+ * Internal hook used by useStorageSource to auto-detect the queue.
+ * Returns null if no StorageQueueProvider is present (web, tests, etc.)
+ */
+declare function useStorageQueueContext(): StorageQueueContextValue | null;
+
 declare function createInCondition(column: string, values: (string | number)[]): string;
 
 declare const TIMEOUT_ERROR_MESSAGE = "Request timed out";
 declare const DEFAULT_QUERY_TIMEOUT = 15000;
 declare function isTimeoutError(error: Error | null | undefined): boolean;
 
+type ConfigurationOptions<T> = {
+    crossOrganization?: boolean;
+};
+type FilterOperator = "or" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "like" | "ilike" | "is" | "in" | "cs" | "cd" | "fts" | "plfts";
+type ValueType = number | string | boolean | null | Date | object;
+type FilterDefinition = {
+    path: string;
+    alias?: string;
+    operator: FilterOperator;
+    negate: boolean;
+    value: ValueType;
+};
+type FilterDefinitions = (FilterComposite | FilterDefinition)[];
+type FilterComposite = {
+    or?: FilterDefinitions;
+    and?: FilterDefinitions;
+};
+type UseDbRealtimeQueryResult<T> = UseDbQuerySingleReturn<T> & {
+    realtimeStatus: "SUBSCRIBED" | "TIMED_OUT" | "CLOSED" | "CHANNEL_ERROR" | "Loading...";
+    isRealtimeConnected: boolean;
+    isRealtimeLoading: boolean;
+};
+type DataType = Record<string, any>;
+declare function convertFilterToRealtimeQuery(filters: FilterDefinitions): string;
+declare function useDbRealtimeQuery<Result extends DataType>(query: PromiseLike<PostgrestSingleResponse$1<Result>>, config?: Omit<UseQueryOptions<PostgrestSingleResponse$1<Result>>, "queryKey" | "queryFn"> & ConfigurationOptions<Result>, primaryKeys?: (keyof ItemType<Result> & string)[]): UseDbRealtimeQueryResult<Result>;
+
 interface AlertProps {
     title: string;
     description: string;
@@ -879,4 +983,4 @@ declare function useResolveFeedback(): _tanstack_react_query.UseMutationResult<{
     }>;
 }, Error, number, unknown>;
 
-export { type SubmitFeedbackParams as $, type AIOptions as A, BUCKETS as B, type CustomPageQueryResult as C, DEFAULT_QUERY_TIMEOUT as D, useUpsertChangelog as E, useDeleteChangelog as F, useUpsertChangelogEntry as G, useMultiUpsertChangelogEntries as H, useDeleteChangelogEntry as I, useMultiDeleteChangelogEntries as J, useUpsertChangelogMedia as K, LiveChangeContext as L, useDeleteChangelogMedia as M, useUploadChangelogMedia as N, useChangelogs as O, usePublishedChangelogs as P, useChangelogById as Q, useChangelogBySlug as R, SupabaseAdapter as S, TIMEOUT_ERROR_MESSAGE as T, type UseMutationSuccessOptions as U, useChangelogEntries as V, useChangelogMedia as W, useFeedbackList as X, type FeedbackListItem as Y, type FeedbackListParams as Z, useSubmitFeedback as _, useLatestOperationLog as a, useApplyFeedback as a0, useResolveFeedback as a1, type UseDbPartialQueryResult as a2, useDbPartialQuery as a3, useAutosaveState as b, useToastError as c, useStorageUrl as d, useStoragePath as e, useMutationSuccess as f, getSupabaseUrl as g, useMutationSuccessRN as h, createSupabaseAdapter as i, getErrorBody as j, type AIResponse as k, useAI as l, type ServerAvailabilityState as m, newTimeActivity as n, useServerAvailability as o, useSearchQuery as p, type UpdateOptions as q, executeAdvanceQuery as r, setSupabaseUrl as s, type StorageObjectMetadata as t, useLiveChangeTracking as u, type BucketName as v, createInCondition as w, isTimeoutError as x, type AlertProps as y, LiveChangeContextProvider as z };
+export { useUpsertChangelogMedia as $, type AttachmentQueueProvider as A, useAI as B, type ServerAvailabilityState as C, useServerAvailability as D, useSearchQuery as E, type UpdateOptions as F, executeAdvanceQuery as G, type CustomPageQueryResult as H, BUCKETS as I, type BucketName as J, createInCondition as K, DEFAULT_QUERY_TIMEOUT as L, isTimeoutError as M, type UseDbRealtimeQueryResult as N, convertFilterToRealtimeQuery as O, type AlertProps as P, LiveChangeContext as Q, LiveChangeContextProvider as R, StorageQueueProvider as S, TIMEOUT_ERROR_MESSAGE as T, type UseAutosaveOptions as U, useUpsertChangelog as V, useDeleteChangelog as W, useUpsertChangelogEntry as X, useMultiUpsertChangelogEntries as Y, useDeleteChangelogEntry as Z, useMultiDeleteChangelogEntries as _, useLatestOperationLog as a, useDeleteChangelogMedia as a0, useUploadChangelogMedia as a1, useChangelogs as a2, usePublishedChangelogs as a3, useChangelogById as a4, useChangelogBySlug as a5, useChangelogEntries as a6, useChangelogMedia as a7, useFeedbackList as a8, type FeedbackListItem as a9, type FeedbackListParams as aa, useSubmitFeedback as ab, type SubmitFeedbackParams as ac, useApplyFeedback as ad, useResolveFeedback as ae, type UseDbPartialQueryResult as af, useDbPartialQuery as ag, useAutosaveState as b, useAutosave as c, type UseAutosaveResult as d, useToastError as e, useStorageSource as f, getStorageUrl as g, type UseStorageSourceOptions as h, type UseStorageSourceResult as i, type StorageQueueProviderProps as j, StorageQueueContext as k, useStorageQueueContext as l, type StorageQueueContextValue as m, newTimeActivity as n, useDbRealtimeQuery as o, getSupabaseUrl as p, type UseMutationSuccessOptions as q, useMutationSuccess as r, setSupabaseUrl as s, useMutationSuccessRN as t, useLiveChangeTracking as u, SupabaseAdapter as v, createSupabaseAdapter as w, getErrorBody as x, type AIOptions as y, type AIResponse as z };

package/dist/{useSupabase-DvWVuHHE.d.ts → useSupabase-DSZNeXnF.d.ts}

@@ -21,7 +21,7 @@ declare function useSupabase(): SupabaseClient<any, "public", "public", any, any
 declare function SupabaseProvider({ children, options, afterInitialize, supabaseClient: supabaseClientProp, }: {
     children: ReactNode;
     options?: SupabaseClientOptions<string & keyof Database>;
-    afterInitialize?: (supabase: SupabaseClient<Database>) => any;
+    afterInitialize?: (supabase: SupabaseClient<Database>) => void | (() => void);
     supabaseClient?: SupabaseClient<Database>;
 }): react_jsx_runtime.JSX.Element;
 

package/dist/with-auth/index.d.ts

@@ -1,8 +1,8 @@
-import { u as useSupabase } from '../useSupabase-DvWVuHHE.js';
+import { u as useSupabase } from '../useSupabase-DSZNeXnF.js';
 import { a as ProfileStatus } from '../setupAuthContext-B76nbIP6.js';
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { useMutation, useQuery } from '@tanstack/react-query';
-export { e as UserMetadataContextProvider, c as UserMetadataContextType, a as UserMetadataInsert, U as UserMetadataRow, b as UserMetadataUpdate, u as useLiveChangesIndicator, h as useSetUserMetadata, i as useUserMetadataState, g as useUserMetadataValue, d as userMetadataContext } from '../UserMetadataContext-B8gVWGMl.js';
+export { e as UserMetadataContextProvider, c as UserMetadataContextType, a as UserMetadataInsert, U as UserMetadataRow, b as UserMetadataUpdate, u as useLiveChangesIndicator, h as useSetUserMetadata, i as useUserMetadataState, g as useUserMetadataValue, d as userMetadataContext } from '../UserMetadataContext-pQb3A8_Q.js';
 import { UseQuerySingleReturn } from '@supabase-cache-helpers/postgrest-react-query';
 import { T as Tables } from '../database.types-ChFCG-4M.js';
 import 'react/jsx-runtime';

package/dist/with-auth/index.js

@@ -5,38 +5,36 @@ import {
   useUserMetadataState,
   useUserMetadataValue,
   userMetadataContext
-} from "../chunk-ADD5MIMK.js";
+} from "../chunk-FESQS4S5.js";
+import {
+  useDbUpsert
+} from "../chunk-NP34C3O3.js";
 import "../chunk-SM73S2DY.js";
-import "../chunk-NSIAAYW3.js";
+import "../chunk-6KN7KLEG.js";
+import "../chunk-5HJLTYRA.js";
 import {
   useAuth,
   useSetupAuth
-} from "../chunk-5BLKZUKM.js";
+} from "../chunk-MREERKQU.js";
 import {
   useDbQuery
-} from "../chunk-WX4ABYIF.js";
-import {
-  useDbUpsert
-} from "../chunk-VGEMLNNM.js";
-import "../chunk-HAWJTZCK.js";
+} from "../chunk-67HMVGV7.js";
+import "../chunk-UBHORKBS.js";
+import "../chunk-RT4O5H2E.js";
 import {
   getSupabaseUrl
 } from "../chunk-GC3TBUWE.js";
 import "../chunk-J4ZVCXZ4.js";
-import {
-  isNullOrWhitespace,
-  isUsable,
-  newUuid
-} from "../chunk-OQ7U6EQ3.js";
-import "../chunk-H6365JPC.js";
-import "../chunk-3PJTNH2L.js";
+import "../chunk-YUX6RGLZ.js";
+import "../chunk-AKIRHA4Q.js";
 import {
   useSupabase
-} from "../chunk-5EFDS7SR.js";
-import "../chunk-P4UZ7IXC.js";
+} from "../chunk-DMVUEJG2.js";
+import "../chunk-7D4SUZUM.js";
 
 // src/hooks/useConsent.ts
 import { useCallback, useMemo } from "react";
+import { isUsable } from "@pol-studios/utils";
 function useConsent() {
   const supabase = useSupabase();
   const {
@@ -888,6 +886,7 @@ var useDataExport_default = useDataExport;
 
 // src/useBackgroundTask.tsx
 import { c as _c4 } from "react/compiler-runtime";
+import { isUsable as isUsable2 } from "@pol-studios/utils";
 import { useToast } from "@pol-studios/hooks/toast";
 function useBackgroundTask() {
   const $ = _c4(12);
@@ -904,16 +903,28 @@ function useBackgroundTask() {
       if (user == null) {
         return;
       }
-      const taskResponse = await supabase.schema("core").from("Task").insert({
-        payload: request.body,
-        handlerId: request.handlerId,
-        title: request.title,
-        description: request.description,
-        createdBy: user.id,
-        payloadLength: JSON.stringify(request.body).length
-      }).select();
-      const task = taskResponse.data?.[0];
-      if (isUsable(task) === false) {
+      const response = await supabase.functions.invoke("background-task-orchestrator", {
+        body: {
+          taskId: request.handlerId,
+          title: request.title,
+          description: request.description,
+          payload: request.body
+        }
+      });
+      if (response.error) {
+        if (response.error.message?.includes("rate limit") || response.error.message?.includes("429")) {
+          toast({
+            title: "Too many requests. Please try again later."
+          });
+        } else {
+          toast({
+            title: "Failed to start task"
+          });
+        }
+        throw response.error;
+      }
+      const task = response.data?.task;
+      if (isUsable2(task) === false) {
         return;
       }
       toast({
@@ -931,17 +942,17 @@ function useBackgroundTask() {
   let t1;
   if ($[4] !== supabase) {
     t1 = async function retryTask2(taskId) {
-      const response = await supabase.functions.invoke("trigger-update", {
+      const response_0 = await supabase.functions.invoke("trigger-update", {
         body: {
           taskId,
           action: "retry"
         }
       });
-      console.log(response.data);
-      if (response.error) {
-        throw response.error;
+      console.log(response_0.data);
+      if (response_0.error) {
+        throw response_0.error;
       }
-      return response.data.id;
+      return response_0.data.id;
     };
     $[4] = supabase;
     $[5] = t1;
@@ -984,6 +995,7 @@ function useBackgroundTask() {
 
 // src/useUserMetadata.tsx
 import { c as _c5 } from "react/compiler-runtime";
+import { isUsable as isUsable3 } from "@pol-studios/utils";
 function useUserMetadata(key) {
   const $ = _c5(16);
   const supabase = useSupabase();
@@ -1012,7 +1024,7 @@ function useUserMetadata(key) {
   }
   let t2;
   if ($[5] !== user) {
-    t2 = isUsable(user);
+    t2 = isUsable3(user);
     $[5] = user;
     $[6] = t2;
   } else {
@@ -1064,6 +1076,7 @@ function useUserMetadata(key) {
 import { c as _c6 } from "react/compiler-runtime";
 import { useMutation as useMutation4 } from "@tanstack/react-query";
 import { Upload } from "tus-js-client";
+import { isNullOrWhitespace, newUuid } from "@pol-studios/utils";
 async function uploadFileWithMetadata(supabase, bucketName, filePath, file, metadata, onProgress) {
   const {
     data: {