@jmruthers/pace-core 0.5.181 → 0.5.183

package/dist/{chunk-ZYTYSTO5.js → chunk-RA3JUFMW.js}

@@ -1,4 +1,5 @@
 import {
+  OrganisationContextRequiredError,
   getAccessLevel,
   getPermissionMap,
   getRBACLogger,
@@ -6,26 +7,179 @@ import {
   isPermitted,
   isPermittedCached,
   resolveAppContext
-} from "./chunk-BVYWGZVV.js";
+} from "./chunk-M7W4CP3M.js";
 import {
-  init_useOrganisations,
   useEvents,
   useOrganisations
-} from "./chunk-LIMSTKYD.js";
+} from "./chunk-QCDXODCA.js";
 import {
-  init_UnifiedAuthProvider,
   useUnifiedAuth
-} from "./chunk-3JI76CYK.js";
+} from "./chunk-FUEYYMX5.js";
 import {
   getCurrentAppName
-} from "./chunk-Q5QRDWKI.js";
+} from "./chunk-F2IMUDXZ.js";
 import {
   createLogger,
-  init_logger
-} from "./chunk-XDNLUEXI.js";
+  logger
+} from "./chunk-PWLANIRT.js";
+
+// src/rbac/secureClient.ts
+import { createClient } from "@supabase/supabase-js";
+var SecureSupabaseClient = class _SecureSupabaseClient {
+  constructor(supabaseUrl, supabaseKey, organisationId, eventId, appId) {
+    this.edgeFunctionClient = null;
+    this.supabaseUrl = supabaseUrl;
+    this.supabaseKey = supabaseKey;
+    this.organisationId = organisationId;
+    this.eventId = eventId;
+    this.appId = appId;
+    this.supabase = createClient(supabaseUrl, supabaseKey, {
+      global: {
+        headers: {
+          "x-organisation-id": organisationId,
+          "x-event-id": eventId || "",
+          "x-app-id": appId || ""
+        }
+      }
+    });
+    this.setupContextInjection();
+    this.setupEdgeFunctionHandling();
+  }
+  /**
+   * Setup context injection for all database operations
+   */
+  setupContextInjection() {
+    const originalFrom = this.supabase.from.bind(this.supabase);
+    this.supabase.from = (table) => {
+      this.validateContext();
+      const query = originalFrom(table);
+      return this.injectContext(query);
+    };
+    const originalRpc = this.supabase.rpc.bind(this.supabase);
+    this.supabase.rpc = (fn, args, options) => {
+      this.validateContext();
+      const contextArgs = {
+        ...args,
+        p_organisation_id: this.organisationId,
+        p_event_id: this.eventId,
+        p_app_id: this.appId
+      };
+      return originalRpc(fn, contextArgs, options);
+    };
+  }
+  /**
+   * Setup Edge Function handling to bypass custom headers
+   * Edge Functions may not have CORS configured to accept custom headers,
+   * so we create a separate client without custom headers for Edge Function calls
+   * 
+   * NOTE: We store the edge function client but don't override functions here.
+   * Instead, we provide a method to get the edge function client for direct use.
+   * This avoids interfering with the main client's operations.
+   */
+  setupEdgeFunctionHandling() {
+    this.edgeFunctionClient = createClient(this.supabaseUrl, this.supabaseKey);
+  }
+  /**
+   * Get a client for Edge Function calls without custom headers
+   * Edge Functions may not have CORS configured to accept custom headers
+   * @returns Supabase client without custom headers for Edge Function calls
+   */
+  getEdgeFunctionClient() {
+    return this.edgeFunctionClient || this.supabase;
+  }
+  /**
+   * Inject organisation context into a query
+   */
+  injectContext(query) {
+    const originalSelect = query.select.bind(query);
+    const originalInsert = query.insert.bind(query);
+    const originalUpdate = query.update.bind(query);
+    const originalDelete = query.delete.bind(query);
+    query.select = (columns) => {
+      const result = originalSelect(columns);
+      return this.addOrganisationFilter(result);
+    };
+    query.insert = (values) => {
+      const contextValues = Array.isArray(values) ? values.map((v) => ({ ...v, organisation_id: this.organisationId })) : { ...values, organisation_id: this.organisationId };
+      return originalInsert(contextValues);
+    };
+    query.update = (values) => {
+      const result = originalUpdate(values);
+      return this.addOrganisationFilter(result);
+    };
+    query.delete = () => {
+      const result = originalDelete();
+      return this.addOrganisationFilter(result);
+    };
+    return query;
+  }
+  /**
+   * Add organisation filter to a query
+   */
+  addOrganisationFilter(query) {
+    return query.eq("organisation_id", this.organisationId);
+  }
+  /**
+   * Validate that required context is present
+   */
+  validateContext() {
+    if (!this.organisationId) {
+      throw new OrganisationContextRequiredError();
+    }
+  }
+  /**
+   * Get the current organisation ID
+   */
+  getOrganisationId() {
+    return this.organisationId;
+  }
+  /**
+   * Get the current event ID
+   */
+  getEventId() {
+    return this.eventId;
+  }
+  /**
+   * Get the current app ID
+   */
+  getAppId() {
+    return this.appId;
+  }
+  /**
+   * Create a new client with updated context
+   */
+  withContext(updates) {
+    return new _SecureSupabaseClient(
+      this.supabaseUrl,
+      this.supabaseKey,
+      updates.organisationId || this.organisationId,
+      updates.eventId !== void 0 ? updates.eventId : this.eventId,
+      updates.appId !== void 0 ? updates.appId : this.appId
+    );
+  }
+  /**
+   * Get the underlying Supabase client (for internal use only)
+   * @internal
+   */
+  getClient() {
+    return new Proxy(this.supabase, {
+      get: (target, prop) => {
+        if (prop === "functions" && this.edgeFunctionClient) {
+          return this.edgeFunctionClient.functions;
+        }
+        return target[prop];
+      }
+    });
+  }
+};
+function createSecureClient(supabaseUrl, supabaseKey, organisationId, eventId, appId) {
+  return new SecureSupabaseClient(supabaseUrl, supabaseKey, organisationId, eventId, appId);
+}
+function fromSupabaseClient(client, organisationId, eventId, appId) {
+  throw new Error("fromSupabaseClient is not supported. Use createSecureClient instead.");
+}
 
 // src/rbac/hooks/useRBAC.ts
-init_UnifiedAuthProvider();
 import { useState, useEffect, useCallback, useMemo } from "react";
 function mapAccessLevelToEventRole(level) {
   switch (level) {
@@ -43,7 +197,7 @@ function mapAccessLevelToEventRole(level) {
   }
 }
 function useRBAC(pageId) {
-  const logger = getRBACLogger();
+  const logger2 = getRBACLogger();
   const {
     user,
     session,
@@ -56,24 +210,6 @@ function useRBAC(pageId) {
     eventLoading
   } = useUnifiedAuth();
   const requiresEvent = appConfig?.requires_event ?? (appConfig === null ? true : false);
-  if (user && session) {
-    const hookInitLog = {
-      appName,
-      requiresEvent,
-      appConfig: appConfig ? JSON.stringify(appConfig) : "null",
-      hasUser: !!user,
-      hasSession: !!session,
-      hasSelectedEvent: !!selectedEvent,
-      eventLoading,
-      selectedEventId: selectedEvent?.event_id,
-      hasSelectedOrganisation: !!selectedOrganisation,
-      organisationId: selectedOrganisation?.id,
-      orgContextReady,
-      orgLoading
-    };
-    logger.warn("[useRBAC] Hook initialized", hookInitLog);
-    console.warn("[useRBAC] Hook initialized (direct log)", hookInitLog);
-  }
   const [globalRole, setGlobalRole] = useState(null);
   const [organisationRole, setOrganisationRole] = useState(null);
   const [eventAppRole, setEventAppRole] = useState(null);
@@ -96,31 +232,17 @@ function useRBAC(pageId) {
     }
     if (orgLoading || !orgContextReady || !selectedOrganisation?.id) {
       setIsLoading(true);
-      logger.warn("[useRBAC] Waiting for organisation context before loading RBAC context", {
-        orgLoading,
-        orgContextReady,
-        hasSelectedOrganisation: !!selectedOrganisation,
-        organisationId: selectedOrganisation?.id,
-        appName
-      });
       return;
     }
     if (requiresEvent) {
       if (eventLoading || !selectedEvent) {
         setIsLoading(true);
-        logger.warn("[useRBAC] Waiting for event context before loading RBAC context", {
-          eventLoading,
-          hasSelectedEvent: !!selectedEvent,
-          appName,
-          selectedEventId: selectedEvent?.event_id,
-          organisationId: selectedOrganisation?.id
-        });
         return;
       }
     }
     setIsLoading(true);
     setError(null);
-    logger.warn("[useRBAC] Loading RBAC context", {
+    logger2.debug("[useRBAC] Loading RBAC context", {
       appName,
       requiresEvent,
       hasSelectedEvent: !!selectedEvent,
@@ -138,7 +260,7 @@ function useRBAC(pageId) {
           appId = resolved.appId;
         } catch (rpcError) {
           if (rpcError?.message?.includes("NetworkError") || rpcError?.message?.includes("fetch")) {
-            logger.warn("[useRBAC] NetworkError resolving app context - may be timing issue, will retry when context is ready", {
+            logger2.warn("[useRBAC] NetworkError resolving app context - may be timing issue, will retry when context is ready", {
               appName,
               error: rpcError.message,
               requiresEvent,
@@ -156,13 +278,6 @@ function useRBAC(pageId) {
         eventId: selectedEvent?.event_id || void 0,
         appId
       };
-      logger.warn("[useRBAC] Building scope for RBAC context", {
-        organisationId: scope.organisationId,
-        eventId: scope.eventId,
-        appId: scope.appId,
-        hasOrganisationId: !!scope.organisationId,
-        hasEventId: !!scope.eventId
-      });
       setCurrentScope(scope);
       const [map, roleContext, accessLevel] = await Promise.all([
         getPermissionMap({ userId: user.id, scope }),
@@ -173,22 +288,23 @@ function useRBAC(pageId) {
       setGlobalRole(roleContext.globalRole);
       setOrganisationRole(roleContext.organisationRole);
       setEventAppRole(roleContext.eventAppRole || mapAccessLevelToEventRole(accessLevel));
-      logger.warn("[useRBAC] RBAC context loaded successfully", {
-        appName,
-        permissionCount: Object.keys(map).length,
-        globalRole: roleContext.globalRole,
-        organisationRole: roleContext.organisationRole,
-        eventAppRole: roleContext.eventAppRole || mapAccessLevelToEventRole(accessLevel)
-      });
+      const permissionCount = Object.keys(map).length;
+      if (permissionCount === 0) {
+        logger2.warn("[useRBAC] RBAC context loaded but returned 0 permissions", {
+          appName,
+          organisationId: selectedOrganisation.id,
+          eventId: selectedEvent?.event_id
+        });
+      }
     } catch (err) {
       const handledError = err instanceof Error ? err : new Error("Failed to load RBAC context");
-      logger.error("[useRBAC] Error loading RBAC context:", handledError);
+      logger2.error("[useRBAC] Error loading RBAC context:", handledError);
       setError(handledError);
       resetState();
     } finally {
       setIsLoading(false);
     }
-  }, [appName, logger, resetState, selectedEvent?.event_id, selectedOrganisation?.id, session, user, requiresEvent, eventLoading, appConfig, orgContextReady, orgLoading]);
+  }, [appName, logger2, resetState, selectedEvent?.event_id, selectedOrganisation?.id, session, user, requiresEvent, eventLoading, appConfig, orgContextReady, orgLoading]);
   const hasGlobalPermission = useCallback(
     (permission) => {
       if (globalRole === "super_admin" || permissionMap["*"]) {
@@ -210,19 +326,6 @@ function useRBAC(pageId) {
   const canManageOrganisation = useMemo(() => isSuperAdmin || organisationRole === "org_admin", [isSuperAdmin, organisationRole]);
   const canManageEvent = useMemo(() => isSuperAdmin || eventAppRole === "event_admin", [isSuperAdmin, eventAppRole]);
   useEffect(() => {
-    logger.warn("[useRBAC] useEffect triggered - calling loadRBACContext", {
-      appName,
-      requiresEvent,
-      eventLoading,
-      hasSelectedEvent: !!selectedEvent,
-      selectedEventId: selectedEvent?.event_id,
-      hasUser: !!user,
-      hasSession: !!session,
-      hasSelectedOrganisation: !!selectedOrganisation,
-      organisationId: selectedOrganisation?.id,
-      orgContextReady,
-      orgLoading
-    });
     loadRBACContext();
   }, [loadRBACContext, appName, requiresEvent, eventLoading, selectedEvent?.event_id, user, session, selectedOrganisation?.id, orgContextReady, orgLoading]);
   return {
@@ -265,7 +368,6 @@ async function createScopeFromEvent(supabase, eventId, appId) {
 }
 
 // src/rbac/hooks/useResolvedScope.ts
-init_logger();
 var log = createLogger("useResolvedScope");
 function useResolvedScope({
   supabase,
@@ -302,6 +404,14 @@ function useResolvedScope({
   useEffect2(() => {
     let cancelled = false;
     const resolveScope = async () => {
+      if (!supabase && !selectedOrganisationId && !selectedEventId) {
+        if (!cancelled) {
+          setResolvedScope(null);
+          setIsLoading(false);
+          setError(null);
+        }
+        return;
+      }
       setIsLoading(true);
       setError(null);
       try {
@@ -403,35 +513,20 @@ function useResolvedScope({
 }
 
 // src/rbac/hooks/usePermissions.ts
-import React, { useState as useState3, useEffect as useEffect3, useCallback as useCallback2, useMemo as useMemo2, useRef as useRef2 } from "react";
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback2, useMemo as useMemo2, useRef as useRef2 } from "react";
 function usePermissions(userId, organisationId, eventId, appId) {
   const [permissions, setPermissions] = useState3({});
   const [isLoading, setIsLoading] = useState3(true);
   const [error, setError] = useState3(null);
   const [fetchTrigger, setFetchTrigger] = useState3(0);
   const isFetchingRef = useRef2(false);
-  const logger = getRBACLogger();
+  const logger2 = getRBACLogger();
   const prevValuesRef = useRef2({ userId, organisationId, eventId, appId });
   const orgId = organisationId || "";
-  logger.warn("[usePermissions] Hook called with scope", {
-    userId,
-    organisationId: orgId,
-    eventId,
-    appId,
-    hasAppId: !!appId,
-    hasOrganisationId: !!orgId
-  });
-  React.useEffect(() => {
-    logger.warn("[usePermissions] Scope changed (useEffect)", {
-      userId,
-      organisationId,
-      eventId,
-      appId,
-      hasAppId: !!appId,
-      hasOrganisationId: !!organisationId
-    });
-  }, [userId, organisationId, eventId, appId]);
   useEffect3(() => {
+    if (!userId) {
+      return;
+    }
     if (!orgId || orgId === null || typeof orgId === "string" && orgId.trim() === "") {
       const timeoutId = setTimeout(() => {
         setError(new Error("Organisation context is required for permission checks"));
@@ -442,74 +537,38 @@ function usePermissions(userId, organisationId, eventId, appId) {
     if (error?.message === "Organisation context is required for permission checks") {
       setError(null);
     }
-  }, [organisationId, error]);
+  }, [userId, organisationId, error]);
   const paramsChanged = prevValuesRef.current.userId !== userId || prevValuesRef.current.organisationId !== organisationId || prevValuesRef.current.eventId !== eventId || prevValuesRef.current.appId !== appId;
   if (paramsChanged) {
-    logger.warn("[usePermissions] Parameters changed - triggering fetch", {
-      userId,
-      organisationId: orgId,
-      eventId,
-      appId,
-      hasAppId: !!appId,
-      prevAppId: prevValuesRef.current.appId,
-      appIdChanged: prevValuesRef.current.appId !== appId
-    });
+    if (prevValuesRef.current.appId !== appId) {
+      logger2.debug("[usePermissions] AppId changed - triggering fetch", {
+        prevAppId: prevValuesRef.current.appId,
+        newAppId: appId
+      });
+    }
     prevValuesRef.current = { userId, organisationId, eventId, appId };
     setFetchTrigger((prev) => prev + 1);
   }
   useEffect3(() => {
     const fetchPermissions = async () => {
-      logger.warn("[usePermissions] Fetch useEffect triggered", {
-        userId,
-        orgId,
-        eventId,
-        appId,
-        hasAppId: !!appId,
-        isFetching: isFetchingRef.current
-      });
       if (isFetchingRef.current) {
-        logger.warn("[usePermissions] Skipping fetch - already fetching", {
-          userId,
-          scope: {
-            organisationId: orgId,
-            eventId,
-            appId
-          }
-        });
         return;
       }
       if (!userId) {
-        logger.warn("[usePermissions] Skipping fetch - no userId");
+        setPermissions({});
+        setIsLoading(false);
+        return;
+      }
+      if (!userId) {
         setPermissions({});
         setIsLoading(false);
         return;
       }
       if (!orgId || orgId === null || typeof orgId === "string" && orgId.trim() === "") {
-        logger.warn("[usePermissions] Skipping fetch - no orgId", {
-          orgId,
-          hasOrgId: !!orgId
-        });
         setIsLoading(true);
         setError(null);
         return;
       }
-      if (!appId) {
-        logger.warn("[usePermissions] Fetching permissions without appId (may return limited permissions)", {
-          userId,
-          organisationId: orgId,
-          eventId,
-          hasAppId: false
-        });
-      }
-      logger.warn("[usePermissions] Fetching permissions", {
-        userId,
-        scope: {
-          organisationId: orgId,
-          eventId,
-          appId
-        },
-        hasAppId: !!appId
-      });
       try {
         isFetchingRef.current = true;
         setIsLoading(true);
@@ -520,18 +579,15 @@ function usePermissions(userId, organisationId, eventId, appId) {
           appId
         };
         const permissionMap = await getPermissionMap({ userId, scope });
-        logger.warn("[usePermissions] Permissions fetched successfully", {
-          permissionCount: Object.keys(permissionMap).length,
-          hasWildcard: !!permissionMap["*"],
-          scope: {
-            organisationId: orgId,
-            eventId,
-            appId
-          }
-        });
+        const permissionCount = Object.keys(permissionMap).length;
+        if (permissionCount === 0 && Object.keys(permissions).length > 0) {
+          logger2.warn("[usePermissions] Permissions fetched but returned empty map", {
+            scope: { organisationId: orgId, eventId, appId }
+          });
+        }
         setPermissions(permissionMap);
       } catch (err) {
-        logger.error("[usePermissions] Failed to fetch permissions:", err);
+        logger2.error("[usePermissions] Failed to fetch permissions:", err);
         setError(err instanceof Error ? err : new Error("Failed to fetch permissions"));
       } finally {
         setIsLoading(false);
@@ -584,8 +640,8 @@ function usePermissions(userId, organisationId, eventId, appId) {
       const permissionMap = await getPermissionMap({ userId, scope });
       setPermissions(permissionMap);
     } catch (err) {
-      const logger2 = getRBACLogger();
-      logger2.error("Failed to refetch permissions:", err);
+      const logger3 = getRBACLogger();
+      logger3.error("Failed to refetch permissions:", err);
       setError(err instanceof Error ? err : new Error("Failed to fetch permissions"));
     } finally {
       setIsLoading(false);
@@ -665,8 +721,8 @@ function useCan(userId, scope, permission, pageId, useCache = true) {
           const result = useCache ? await isPermittedCached({ userId, scope: validScope, permission, pageId }) : await isPermitted({ userId, scope: validScope, permission, pageId });
           setCan(result);
         } catch (err) {
-          const logger = getRBACLogger();
-          logger.error("Permission check error:", { permission, error: err });
+          const logger2 = getRBACLogger();
+          logger2.error("Permission check error:", { permission, error: err });
           setError(err instanceof Error ? err : new Error("Failed to check permission"));
           setCan(false);
         } finally {
@@ -901,8 +957,6 @@ function useCachedPermissions(userId, scope) {
 }
 
 // src/rbac/hooks/useResourcePermissions.ts
-init_UnifiedAuthProvider();
-init_useOrganisations();
 import { useMemo as useMemo3 } from "react";
 function useResourcePermissions(resource, options = {}) {
   const { enableRead = false, requireScope = true } = options;
@@ -1017,7 +1071,6 @@ function useResourcePermissions(resource, options = {}) {
 }
 
 // src/rbac/hooks/useRoleManagement.ts
-init_UnifiedAuthProvider();
 import { useState as useState4, useCallback as useCallback3 } from "react";
 function useRoleManagement() {
   const { user, supabase } = useUnifiedAuth();
@@ -1141,7 +1194,106 @@ function useRoleManagement() {
   };
 }
 
+// src/rbac/hooks/useSecureSupabase.ts
+import { useMemo as useMemo4, useRef as useRef3 } from "react";
+var secureClientCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 5;
+function getCacheKey(organisationId, eventId, appId) {
+  return `${organisationId}-${eventId || "no-event"}-${appId || "no-app"}`;
+}
+function getSupabaseConfig() {
+  const getEnvVar = (key) => {
+    if (typeof import.meta !== "undefined" && import.meta.env) {
+      return import.meta.env[key];
+    }
+    if (typeof process !== "undefined" && process.env) {
+      return process.env[key];
+    }
+    return void 0;
+  };
+  const supabaseUrl = getEnvVar("VITE_SUPABASE_URL") || getEnvVar("NEXT_PUBLIC_SUPABASE_URL") || null;
+  const supabaseKey = getEnvVar("VITE_SUPABASE_ANON_KEY") || getEnvVar("NEXT_PUBLIC_SUPABASE_ANON_KEY") || null;
+  if (!supabaseUrl || !supabaseKey) {
+    return null;
+  }
+  return { url: supabaseUrl, key: supabaseKey };
+}
+function useSecureSupabase(baseClient) {
+  const { user, supabase: authSupabase } = useUnifiedAuth();
+  const { selectedOrganisation } = useOrganisations();
+  const eventsContext = useEvents();
+  const { selectedEvent } = eventsContext;
+  const eventLoading = "eventLoading" in eventsContext ? eventsContext.eventLoading : false;
+  const { resolvedScope } = useResolvedScope({
+    supabase: authSupabase || null,
+    selectedOrganisationId: selectedOrganisation?.id || null,
+    selectedEventId: selectedEvent?.event_id || null
+  });
+  const prevContextRef = useRef3({
+    organisationId: void 0,
+    eventId: void 0,
+    appId: void 0
+  });
+  return useMemo4(() => {
+    if (eventLoading) {
+      return baseClient || authSupabase || null;
+    }
+    if (selectedOrganisation?.id && user?.id) {
+      const organisationId = selectedOrganisation.id;
+      const eventId = selectedEvent?.event_id;
+      const appId = resolvedScope?.appId;
+      prevContextRef.current = { organisationId, eventId, appId };
+      const cacheKey = getCacheKey(organisationId, eventId, appId);
+      const cachedClient = secureClientCache.get(cacheKey);
+      if (cachedClient) {
+        return cachedClient.getClient();
+      }
+      const config = getSupabaseConfig();
+      if (!config || !config.url || !config.key) {
+        logger.warn("useSecureSupabase", "Missing Supabase environment variables. Falling back to base client.", {
+          note: "Ensure VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY are set in your environment."
+        });
+        return baseClient || authSupabase || null;
+      }
+      try {
+        const secureClient = createSecureClient(
+          config.url,
+          config.key,
+          organisationId,
+          // organisationId is string, UUID is string alias
+          eventId,
+          appId
+          // appId is string | undefined, UUID is string alias
+        );
+        secureClientCache.set(cacheKey, secureClient);
+        if (secureClientCache.size > MAX_CACHE_SIZE) {
+          const firstKey = secureClientCache.keys().next().value;
+          if (firstKey) {
+            secureClientCache.delete(firstKey);
+          }
+        }
+        return secureClient.getClient();
+      } catch (error) {
+        logger.error("useSecureSupabase", "Failed to create secure client", error);
+        return baseClient || authSupabase || null;
+      }
+    }
+    return baseClient || authSupabase || null;
+  }, [
+    selectedOrganisation?.id,
+    selectedEvent?.event_id,
+    user?.id,
+    eventLoading,
+    resolvedScope?.appId,
+    baseClient,
+    authSupabase
+  ]);
+}
+
 export {
+  SecureSupabaseClient,
+  createSecureClient,
+  fromSupabaseClient,
   useRBAC,
   createScopeFromEvent,
   useResolvedScope,
@@ -1153,6 +1305,7 @@ export {
   useHasAllPermissions,
   useCachedPermissions,
   useResourcePermissions,
-  useRoleManagement
+  useRoleManagement,
+  useSecureSupabase
 };
-//# sourceMappingURL=chunk-ZYTYSTO5.js.map
+//# sourceMappingURL=chunk-RA3JUFMW.js.map