@jmruthers/pace-core 0.2.7 → 0.5.1

package/dist/{chunk-ETEJVKYK.js → chunk-6CR3MRZN.js}

@@ -1,13 +1,985 @@
 import {
+  AccessLevel,
+  init_unified
+} from "./chunk-YDJW5XTN.js";
+import {
+  DebugLogger,
   cn,
-  init_cn
-} from "./chunk-OHXGNT3K.js";
+  init_cn,
+  init_debugLogger
+} from "./chunk-OYRY44Q2.js";
 import {
   __commonJS,
   __esm,
+  __export,
   __toESM
 } from "./chunk-PLDDJCW6.js";
 
+// src/providers/AuthProvider.tsx
+import { createContext, useContext, useState, useEffect, useCallback, useMemo } from "react";
+import { AuthError } from "@supabase/supabase-js";
+import { jsx } from "react/jsx-runtime";
+function AuthProvider({ children, supabaseClient }) {
+  const [user, setUser] = useState(null);
+  const [session, setSession] = useState(null);
+  const [authLoading, setAuthLoading] = useState(true);
+  const [authError, setAuthError] = useState(null);
+  useEffect(() => {
+    const handleError = (event) => {
+      if (event.error?.message?.includes("AuthSessionMissingError") || event.error?.message?.includes("Auth session missing")) {
+        console.warn("[AuthProvider] Suppressing AuthSessionMissingError during logout");
+        event.preventDefault();
+        return false;
+      }
+    };
+    const handleUnhandledRejection = (event) => {
+      if (event.reason?.message?.includes("AuthSessionMissingError") || event.reason?.message?.includes("Auth session missing")) {
+        console.warn("[AuthProvider] Suppressing unhandled AuthSessionMissingError");
+        event.preventDefault();
+        return false;
+      }
+    };
+    window.addEventListener("error", handleError);
+    window.addEventListener("unhandledrejection", handleUnhandledRejection);
+    return () => {
+      window.removeEventListener("error", handleError);
+      window.removeEventListener("unhandledrejection", handleUnhandledRejection);
+    };
+  }, []);
+  useEffect(() => {
+    if (!supabaseClient) return;
+    const loadInitialUser = async () => {
+      try {
+        const response = await supabaseClient.auth.getUser();
+        const { data: { user: initialUser }, error } = response || { data: { user: null }, error: null };
+        if (error) {
+          console.warn("Failed to get initial user:", error);
+          setAuthLoading(false);
+          return;
+        }
+        if (initialUser) {
+          setUser(initialUser);
+        }
+        setAuthLoading(false);
+      } catch (error) {
+        console.error("Error loading initial user:", error);
+        setAuthLoading(false);
+      }
+    };
+    const timeoutId = setTimeout(() => {
+      if (authLoading && !user && !session) {
+        loadInitialUser();
+      }
+    }, 100);
+    return () => clearTimeout(timeoutId);
+  }, [supabaseClient, authLoading, user, session]);
+  useEffect(() => {
+    if (!supabaseClient) {
+      setAuthLoading(false);
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      if (authLoading) {
+        console.warn("AuthProvider: Auth loading timeout reached");
+        setAuthLoading(false);
+      }
+    }, 2e3);
+    try {
+      DebugLogger.log("AuthProvider", "Setting up auth state change listener...");
+      const authStateChange = supabaseClient.auth.onAuthStateChange(
+        (event, session2) => {
+          try {
+            DebugLogger.log("AuthProvider", "Auth state changed:", event, session2?.user?.email);
+            clearTimeout(timeoutId);
+            if (event === "SIGNED_OUT") {
+              DebugLogger.log("AuthProvider", "User signed out, clearing all state");
+              setSession(null);
+              setUser(null);
+              setAuthLoading(false);
+              setAuthError(null);
+            } else {
+              setSession(session2);
+              setUser(session2?.user ?? null);
+              setAuthLoading(false);
+              if (session2) {
+                setAuthError(null);
+              }
+            }
+          } catch (error) {
+            console.warn("[AuthProvider] Error in auth state change handler:", error);
+            setAuthLoading(false);
+          }
+        }
+      );
+      const subscription = authStateChange?.data?.subscription || authStateChange;
+      return () => {
+        clearTimeout(timeoutId);
+        if (subscription && typeof subscription.unsubscribe === "function") {
+          DebugLogger.log("AuthProvider", "Cleaning up auth state listener");
+          subscription.unsubscribe();
+        }
+      };
+    } catch (error) {
+      console.error("AuthProvider: Error setting up auth state change listener:", error);
+      if (error instanceof Error && !error.message.includes("No API key found") && !error.message.includes("AuthSessionMissingError") && !error.message.includes("Auth session missing")) {
+        setAuthError(error);
+      }
+      setAuthLoading(false);
+      clearTimeout(timeoutId);
+      return () => {
+      };
+    }
+  }, [supabaseClient]);
+  const signIn = useCallback(async (email, password) => {
+    if (!supabaseClient) {
+      const error = new Error("No Supabase client provided");
+      setAuthError(error);
+      return { error };
+    }
+    setAuthLoading(true);
+    setAuthError(null);
+    try {
+      const { error } = await supabaseClient.auth.signInWithPassword({ email, password: password || "" });
+      if (error) {
+        setAuthError(error);
+      }
+      return { error };
+    } catch (err) {
+      const authError2 = err;
+      setAuthError(authError2);
+      return { error: authError2 };
+    } finally {
+      setAuthLoading(false);
+    }
+  }, [supabaseClient]);
+  const signUp = useCallback(async (email, password) => {
+    if (!supabaseClient) {
+      const error = new Error("No Supabase client provided");
+      setAuthError(error);
+      return { error };
+    }
+    setAuthError(null);
+    try {
+      const { error } = await supabaseClient.auth.signUp({ email, password });
+      if (error) {
+        setAuthError(error);
+      }
+      return { error };
+    } catch (err) {
+      const authError2 = err;
+      setAuthError(authError2);
+      return { error: authError2 };
+    }
+  }, [supabaseClient]);
+  const signOut = useCallback(async () => {
+    DebugLogger.log("AuthProvider", "signOut called");
+    setAuthLoading(false);
+    if (!supabaseClient) {
+      DebugLogger.log("AuthProvider", "No supabase client, clearing state manually");
+      setUser(null);
+      setSession(null);
+      setAuthError(null);
+      return { error: null };
+    }
+    DebugLogger.log("AuthProvider", "Pre-clearing state before signOut call");
+    setUser(null);
+    setSession(null);
+    setAuthError(null);
+    try {
+      DebugLogger.log("AuthProvider", "Calling supabase signOut");
+      const signOutPromise = supabaseClient.auth.signOut();
+      const timeoutPromise = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("SignOut timeout")), 3e3)
+      );
+      const { error } = await Promise.race([signOutPromise, timeoutPromise]);
+      if (error && !error.message?.includes("SignOut timeout")) {
+        console.error("[AuthProvider] signOut error:", error);
+      }
+      DebugLogger.log("AuthProvider", "signOut process completed");
+      return { error: null };
+    } catch (err) {
+      console.warn("[AuthProvider] signOut exception (ignored):", err);
+      return { error: null };
+    }
+  }, [supabaseClient]);
+  const resetPassword = useCallback(async (email) => {
+    if (!supabaseClient) {
+      const error = new Error("No Supabase client provided");
+      setAuthError(error);
+      return { error };
+    }
+    setAuthError(null);
+    try {
+      const { error } = await supabaseClient.auth.resetPasswordForEmail(email);
+      if (error) {
+        setAuthError(error);
+      }
+      return { error };
+    } catch (err) {
+      const authError2 = err;
+      setAuthError(authError2);
+      return { error: authError2 };
+    }
+  }, [supabaseClient]);
+  const updatePassword = useCallback(async (password) => {
+    if (!supabaseClient) return { error: new AuthError("Supabase client not available.", 500) };
+    const { error } = await supabaseClient.auth.updateUser({ password });
+    if (error) {
+      setAuthError(error);
+    }
+    return { error };
+  }, [supabaseClient]);
+  const refreshSession = useCallback(async () => {
+    if (!supabaseClient) {
+      const error = new Error("No Supabase client provided");
+      setAuthError(error);
+      return { error };
+    }
+    setAuthError(null);
+    try {
+      const { error } = await supabaseClient.auth.refreshSession();
+      if (error) {
+        setAuthError(error);
+      }
+      return { error };
+    } catch (err) {
+      const authError2 = err;
+      setAuthError(authError2);
+      return { error: authError2 };
+    }
+  }, [supabaseClient]);
+  const isAuthenticated = !!user;
+  const contextValue = useMemo(() => ({
+    user,
+    session,
+    isAuthenticated,
+    authLoading,
+    authError,
+    error: authError,
+    // Alias for backward compatibility
+    supabase: supabaseClient || null,
+    signIn,
+    signUp,
+    signOut,
+    resetPassword,
+    updatePassword,
+    refreshSession
+  }), [
+    user,
+    session,
+    isAuthenticated,
+    authLoading,
+    authError,
+    supabaseClient,
+    signIn,
+    signUp,
+    signOut,
+    resetPassword,
+    updatePassword,
+    refreshSession
+  ]);
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value: contextValue, children });
+}
+var AuthContext, useAuth;
+var init_AuthProvider = __esm({
+  "src/providers/AuthProvider.tsx"() {
+    "use strict";
+    init_debugLogger();
+    AuthContext = createContext(void 0);
+    useAuth = () => {
+      const context = useContext(AuthContext);
+      if (!context) {
+        throw new Error("useAuth must be used within an AuthProvider");
+      }
+      return context;
+    };
+  }
+});
+
+// src/providers/RBACProvider.tsx
+import { createContext as createContext2, useContext as useContext2, useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useMemo as useMemo2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function RBACProvider({
+  children,
+  supabaseClient,
+  user,
+  session,
+  appName,
+  enableRBAC = false,
+  persistState = true,
+  enablePersistence,
+  requireOrganisationContext: _requireOrganisationContext = true
+}) {
+  const shouldPersist = enablePersistence !== void 0 ? enablePersistence : persistState;
+  const [permissions, setPermissions] = useState2({});
+  const [roles, setRoles] = useState2([]);
+  const [accessLevel, setAccessLevel] = useState2("viewer" /* VIEWER */);
+  const [rbacLoading, setRbacLoading] = useState2(false);
+  const [rbacError, setRbacError] = useState2(null);
+  const [selectedEventId, setSelectedEventId] = useState2(null);
+  const [appConfig, setAppConfig] = useState2(null);
+  const [userEventAccess, setUserEventAccess] = useState2([]);
+  const [eventAccessLoading, setEventAccessLoading] = useState2(false);
+  const [selectedOrganisationId, _setSelectedOrganisationId] = useState2(null);
+  useEffect2(() => {
+    if (!supabaseClient) return;
+    const loadAppConfig = async () => {
+      try {
+        const { getCurrentAppName } = await import("./appNameResolver-7GHF5ED2.js");
+        const resolvedAppName = getCurrentAppName() || appName;
+        const { data: appData, error: appError } = await supabaseClient.from("rbac_apps").select("id").eq("name", resolvedAppName).eq("is_active", true).single();
+        if (appError || !appData) {
+          console.warn("App not found or inactive:", resolvedAppName);
+          setAppConfig({
+            supports_direct_access: false,
+            requires_event: true
+          });
+          return;
+        }
+        const response = await supabaseClient.rpc("get_app_config", {
+          p_app_id: appData.id
+        });
+        const { data } = response || {};
+        if (data && data.length > 0) {
+          setAppConfig({
+            supports_direct_access: data[0].supports_direct_access,
+            requires_event: data[0].requires_event
+          });
+        } else {
+          setAppConfig({
+            supports_direct_access: false,
+            requires_event: true
+          });
+        }
+      } catch (error) {
+        console.warn("Clearing corrupted localStorage data");
+        if (typeof localStorage !== "undefined") {
+          localStorage.removeItem(STORAGE_KEYS.SELECTED_EVENT);
+        }
+        console.warn("Failed to load app configuration:", error);
+        setAppConfig({
+          supports_direct_access: false,
+          requires_event: true
+        });
+      }
+    };
+    loadAppConfig();
+  }, [supabaseClient, appName]);
+  useEffect2(() => {
+    const isSuperAdmin = user?.user_metadata?.globalRole === "super_admin";
+    if (isSuperAdmin) {
+      setRoles(["super_admin"]);
+    } else {
+      setRoles([]);
+    }
+  }, [user]);
+  useEffect2(() => {
+    if (!shouldPersist) return;
+    try {
+      const persistedEvent = localStorage.getItem(STORAGE_KEYS.SELECTED_EVENT);
+      if (persistedEvent) {
+        setSelectedEventId(JSON.parse(persistedEvent));
+      }
+    } catch (error) {
+      console.warn("Clearing corrupted localStorage data");
+      localStorage.removeItem(STORAGE_KEYS.SELECTED_EVENT);
+    }
+  }, [shouldPersist]);
+  useEffect2(() => {
+    if (!shouldPersist) return;
+    try {
+      if (selectedEventId) {
+        localStorage.setItem(
+          STORAGE_KEYS.SELECTED_EVENT,
+          JSON.stringify(selectedEventId)
+        );
+      } else {
+        localStorage.removeItem(STORAGE_KEYS.SELECTED_EVENT);
+      }
+    } catch (error) {
+      console.warn("Clearing corrupted localStorage data");
+      localStorage.removeItem(STORAGE_KEYS.SELECTED_EVENT);
+      console.warn("Failed to persist auth state:", error);
+    }
+  }, [selectedEventId, shouldPersist]);
+  const refreshPermissions = useCallback2(async (eventId) => {
+    if (!supabaseClient || !user || !appConfig || !session) {
+      DebugLogger.log("RBACProvider", "refreshPermissions: Missing required dependencies, clearing permissions");
+      setPermissions({});
+      setRoles([]);
+      setAccessLevel("viewer" /* VIEWER */);
+      return;
+    }
+    const isSuperAdmin = user?.user_metadata?.globalRole === "super_admin";
+    if (isSuperAdmin) {
+      setPermissions({
+        "admin:create": true,
+        "admin:read": true,
+        "admin:update": true,
+        "admin:delete": true,
+        "users:create": true,
+        "users:read": true,
+        "users:update": true,
+        "users:delete": true,
+        "events:create": true,
+        "events:read": true,
+        "events:update": true,
+        "events:delete": true
+      });
+      setRoles(["super_admin"]);
+      setAccessLevel("admin" /* ADMIN */);
+      return;
+    }
+    const shouldLoadDirectPermissions = !eventId && !appConfig.requires_event;
+    const shouldLoadEventPermissions = eventId;
+    const shouldClearPermissions = !eventId && appConfig.requires_event;
+    if (shouldClearPermissions) {
+      setPermissions({});
+      setRoles([]);
+      setAccessLevel("viewer" /* VIEWER */);
+      return;
+    }
+    if (!shouldLoadDirectPermissions && !shouldLoadEventPermissions) {
+      return;
+    }
+    setRbacLoading(true);
+    setRbacError(null);
+    try {
+      const { getCurrentAppName } = await import("./appNameResolver-7GHF5ED2.js");
+      const resolvedAppName = getCurrentAppName() || appName;
+      const { data: appData, error: appError } = await supabaseClient.from("rbac_apps").select("id").eq("name", resolvedAppName).eq("is_active", true).single();
+      if (appError || !appData) {
+        console.warn("App not found or inactive:", resolvedAppName);
+        setRbacLoading(false);
+        return;
+      }
+      const { data, error } = await supabaseClient.rpc("get_rbac_permissions", {
+        p_user_id: user.id,
+        p_app_id: appData.id,
+        p_event_id: eventId || null,
+        p_organisation_id: selectedOrganisationId || null
+      });
+      if (error) {
+        throw error;
+      }
+      const { permissions: permissions2, roles: roles2, access_level } = transformRBACPermissions(data, appName);
+      setPermissions(permissions2);
+      setRoles(roles2);
+      setAccessLevel(access_level);
+    } catch (err) {
+      setRbacError(err);
+    } finally {
+      setRbacLoading(false);
+    }
+  }, [supabaseClient, user, session, appName, appConfig, selectedOrganisationId]);
+  const loadUserEventAccess = useCallback2(async () => {
+    if (!supabaseClient || !user || !session) {
+      DebugLogger.log("RBACProvider", "loadUserEventAccess: Missing required dependencies, clearing event access");
+      setUserEventAccess([]);
+      return;
+    }
+    setEventAccessLoading(true);
+    try {
+      const { getCurrentAppName } = await import("./appNameResolver-7GHF5ED2.js");
+      const resolvedAppName = getCurrentAppName() || appName;
+      const { data: appData, error: appError } = await supabaseClient.from("rbac_apps").select("id").eq("name", resolvedAppName).eq("is_active", true).single();
+      if (appError || !appData) {
+        console.warn("App not found or inactive:", resolvedAppName);
+        setEventAccessLoading(false);
+        return;
+      }
+      const { data, error } = await supabaseClient.from("rbac_event_app_roles").select(`
+          event_id,
+          role,
+          granted_at
+        `).eq("user_id", user.id).eq("app_id", appData.id);
+      if (error) {
+        console.error("Failed to load user event access:", error);
+        setUserEventAccess([]);
+        return;
+      }
+      const eventAccess = data?.map((item) => ({
+        event_id: item.event_id,
+        event_name: "Unknown Event",
+        // Event details not available in this query
+        event_description: null,
+        // Not available in this schema
+        start_date: "",
+        // Event date not available in this query
+        end_date: "",
+        // Event date not available in this query
+        event_status: "unknown",
+        // Not available in this schema
+        app_id: appData.id,
+        access_level: item.role,
+        // Map role to access_level
+        granted_at: item.granted_at,
+        organisation_id: ""
+        // Will be populated from event's organisation_id if needed
+      })) || [];
+      setUserEventAccess(eventAccess);
+    } catch (error) {
+      console.warn("Clearing corrupted localStorage data");
+      localStorage.removeItem(STORAGE_KEYS.SELECTED_EVENT);
+      console.error("Error loading user event access:", error);
+      setUserEventAccess([]);
+    } finally {
+      setEventAccessLoading(false);
+    }
+  }, [supabaseClient, user, session, appName]);
+  const getUserEventAccess = useCallback2((eventId) => {
+    return userEventAccess.find((access) => access.event_id === eventId);
+  }, [userEventAccess]);
+  useEffect2(() => {
+    if (!user || !appConfig || !session) {
+      DebugLogger.log("RBACProvider", "Skipping permission refresh - no user, session, or app config");
+      return;
+    }
+    const isSuperAdmin = user?.user_metadata?.globalRole === "super_admin";
+    if (isSuperAdmin) {
+      setPermissions({
+        "admin:create": true,
+        "admin:read": true,
+        "admin:update": true,
+        "admin:delete": true,
+        "users:create": true,
+        "users:read": true,
+        "users:update": true,
+        "users:delete": true,
+        "events:create": true,
+        "events:read": true,
+        "events:update": true,
+        "events:delete": true
+      });
+      setRoles(["super_admin"]);
+      setAccessLevel("admin" /* ADMIN */);
+      return;
+    }
+    if (selectedEventId) {
+      refreshPermissions(selectedEventId);
+    } else if (!appConfig.requires_event) {
+      refreshPermissions();
+    } else {
+      setPermissions({});
+      setRoles([]);
+      setAccessLevel("viewer" /* VIEWER */);
+    }
+  }, [selectedEventId, user, session, appConfig, refreshPermissions]);
+  useEffect2(() => {
+    let isMounted = true;
+    if (user && session) {
+      DebugLogger.log("RBACProvider", "Loading user event access for authenticated user");
+      loadUserEventAccess().catch((error) => {
+        if (isMounted) {
+          console.error("Error loading user event access:", error);
+        }
+      });
+    } else {
+      DebugLogger.log("RBACProvider", "Clearing user event access - no user or session");
+      if (isMounted) {
+        setUserEventAccess([]);
+      }
+    }
+    return () => {
+      isMounted = false;
+    };
+  }, [user, session, loadUserEventAccess]);
+  const hasPermission = useCallback2((permission) => {
+    const hasPerm = !!permissions[permission];
+    return hasPerm;
+  }, [permissions]);
+  const hasAnyPermission = useCallback2((perms) => perms.some((p) => !!permissions[p]), [permissions]);
+  const hasAllPermissions = useCallback2((perms) => perms.every((p) => !!permissions[p]), [permissions]);
+  const hasRole = useCallback2((role) => {
+    const isSuperAdmin = user?.user_metadata?.globalRole === "super_admin";
+    if (role.toLowerCase() === "super_admin") {
+      return isSuperAdmin;
+    }
+    return roles.includes(role);
+  }, [roles, user]);
+  const hasAccessLevel = useCallback2((level) => {
+    const levels = Object.values(AccessLevel);
+    return levels.indexOf(accessLevel) >= levels.indexOf(level);
+  }, [accessLevel]);
+  const canAccess = useCallback2((resource, action) => {
+    const permission = `${resource}:${action}`;
+    const hasAccess = hasPermission(permission);
+    return hasAccess;
+  }, [hasPermission]);
+  const validatePermission = useCallback2(async (permission) => hasPermission(permission), [hasPermission]);
+  const validateAccess = useCallback2(async (resource, action) => {
+    return Promise.resolve(canAccess(resource, action));
+  }, [canAccess]);
+  const contextValue = useMemo2(() => ({
+    permissions,
+    roles,
+    accessLevel,
+    rbacLoading,
+    rbacError,
+    selectedEventId,
+    appConfig,
+    userEventAccess,
+    eventAccessLoading,
+    // Organisation context
+    selectedOrganisationId,
+    requireOrganisationContext: () => {
+      if (!selectedOrganisationId) {
+        throw new Error("Organisation context is required but not available");
+      }
+      return selectedOrganisationId;
+    },
+    hasPermission,
+    hasAnyPermission,
+    hasAllPermissions,
+    hasRole,
+    hasAccessLevel,
+    canAccess,
+    validatePermission,
+    validateAccess,
+    refreshPermissions,
+    setSelectedEventId,
+    // New RBAC system support
+    rbacEnabled: enableRBAC,
+    rbacContext: void 0,
+    // Will be populated by useRBAC hook when enabled
+    loadUserEventAccess,
+    getUserEventAccess
+  }), [
+    permissions,
+    roles,
+    accessLevel,
+    rbacLoading,
+    rbacError,
+    selectedEventId,
+    appConfig,
+    userEventAccess,
+    eventAccessLoading,
+    selectedOrganisationId,
+    hasPermission,
+    hasAnyPermission,
+    hasAllPermissions,
+    hasRole,
+    hasAccessLevel,
+    canAccess,
+    validatePermission,
+    validateAccess,
+    refreshPermissions,
+    setSelectedEventId,
+    enableRBAC,
+    loadUserEventAccess,
+    getUserEventAccess
+  ]);
+  return /* @__PURE__ */ jsx2(RBACContext.Provider, { value: contextValue, children });
+}
+var RBACContext, useRBAC, STORAGE_KEYS, transformRBACPermissions;
+var init_RBACProvider = __esm({
+  "src/providers/RBACProvider.tsx"() {
+    "use strict";
+    init_unified();
+    init_debugLogger();
+    RBACContext = createContext2(void 0);
+    useRBAC = () => {
+      const context = useContext2(RBACContext);
+      if (!context) {
+        throw new Error("useRBAC must be used within an RBACProvider");
+      }
+      return context;
+    };
+    STORAGE_KEYS = {
+      SELECTED_EVENT: "pace-core-selected-event"
+    };
+    transformRBACPermissions = (rbacData, _appName) => {
+      const permissions = {};
+      let roles = [];
+      let access_level = "viewer" /* VIEWER */;
+      if (!rbacData || !Array.isArray(rbacData)) {
+        return { permissions: {}, roles: ["viewer"], access_level: "viewer" /* VIEWER */ };
+      }
+      const superAdminPerm = rbacData.find((p) => p.permission_type === "all_permissions");
+      if (superAdminPerm) {
+        return {
+          permissions: { "all:all": true },
+          roles: ["super"],
+          access_level: "super" /* SUPER */
+        };
+      }
+      const eventAppPerms = rbacData.filter((p) => p.permission_type === "event_app_access");
+      if (eventAppPerms.length > 0) {
+        const role = eventAppPerms[0].role_name;
+        switch (role) {
+          case "event_admin":
+            access_level = "admin" /* ADMIN */;
+            roles = ["admin"];
+            break;
+          case "planner":
+            access_level = "planner" /* PLANNER */;
+            roles = ["planner"];
+            break;
+          case "participant":
+            access_level = "participant" /* PARTICIPANT */;
+            roles = ["participant"];
+            break;
+          case "editor":
+            access_level = "editor" /* EDITOR */;
+            roles = ["editor"];
+            break;
+          case "viewer":
+          default:
+            access_level = "viewer" /* VIEWER */;
+            roles = ["viewer"];
+            break;
+        }
+        const basePermissions = ["read"];
+        if (["event_admin", "planner"].includes(role)) {
+          basePermissions.push("create", "update");
+        }
+        if (role === "event_admin") {
+          basePermissions.push("delete");
+        }
+        basePermissions.forEach((operation) => {
+          permissions[`default:${operation}`] = true;
+        });
+      }
+      const orgPerms = rbacData.filter((p) => p.permission_type === "organisation_access");
+      if (orgPerms.length > 0) {
+        const role = orgPerms[0].role_name;
+        if (role === "org_admin") {
+          access_level = "admin" /* ADMIN */;
+          roles = ["admin"];
+          ["create", "read", "update", "delete"].forEach((operation) => {
+            permissions[`default:${operation}`] = true;
+          });
+        }
+      }
+      return { permissions, roles, access_level };
+    };
+  }
+});
+
+// src/hooks/useInactivityTracker.ts
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback3, useRef } from "react";
+function throttle(func, limit) {
+  let inThrottle;
+  return function(...args) {
+    if (!inThrottle) {
+      func.apply(this, args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, limit);
+    }
+  };
+}
+function useInactivityTracker({
+  idleTimeoutMs = 30 * 60 * 1e3,
+  // 30 minutes
+  warnBeforeMs = 60 * 1e3,
+  // 1 minute
+  onIdle,
+  onWarning,
+  onActivity,
+  enabled = true,
+  storageKey = "pace-core-inactivity",
+  channelName = "pace-core-inactivity"
+} = {}) {
+  const [isIdle, setIsIdle] = useState3(false);
+  const [timeRemaining, setTimeRemaining] = useState3(idleTimeoutMs);
+  const [showWarning, setShowWarning] = useState3(false);
+  const [isTracking, setIsTracking] = useState3(false);
+  useEffect3(() => {
+    if (!enabled) {
+      setIsTracking(false);
+      setIsIdle(false);
+      setShowWarning(false);
+      setTimeRemaining(idleTimeoutMs);
+    }
+  }, [enabled, idleTimeoutMs]);
+  const timeoutRef = useRef(null);
+  const warningTimeoutRef = useRef(null);
+  const countdownIntervalRef = useRef(null);
+  const lastActivityRef = useRef(Date.now());
+  const channelRef = useRef(null);
+  const clearTimers = useCallback3(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    if (warningTimeoutRef.current) {
+      clearTimeout(warningTimeoutRef.current);
+      warningTimeoutRef.current = null;
+    }
+    if (countdownIntervalRef.current) {
+      clearInterval(countdownIntervalRef.current);
+      countdownIntervalRef.current = null;
+    }
+  }, []);
+  const resetActivity = useCallback3((skipActivityCallback = false) => {
+    if (!enabled) return;
+    const now = Date.now();
+    lastActivityRef.current = now;
+    clearTimers();
+    setIsIdle(false);
+    setShowWarning(false);
+    setTimeRemaining(idleTimeoutMs);
+    if (!skipActivityCallback) {
+      onActivity?.();
+    }
+    const warningTime = idleTimeoutMs - warnBeforeMs;
+    if (warningTime > 0) {
+      warningTimeoutRef.current = setTimeout(() => {
+        setShowWarning(true);
+        onWarning?.();
+      }, warningTime);
+    }
+    timeoutRef.current = setTimeout(() => {
+      setIsIdle(true);
+      onIdle?.();
+    }, idleTimeoutMs);
+    countdownIntervalRef.current = setInterval(() => {
+      const elapsed = Date.now() - lastActivityRef.current;
+      const remaining = Math.max(0, idleTimeoutMs - elapsed);
+      setTimeRemaining(remaining);
+      if (remaining === 0) {
+        clearTimers();
+      }
+    }, 1e3);
+    try {
+      localStorage.setItem(storageKey, now.toString());
+    } catch (error) {
+      console.warn("[useInactivityTracker] Failed to persist activity time:", error);
+    }
+    try {
+      if (channelRef.current) {
+        channelRef.current.postMessage({ type: "activity", timestamp: now });
+      }
+    } catch (error) {
+      console.warn("[useInactivityTracker] Failed to broadcast activity:", error);
+    }
+  }, [enabled, idleTimeoutMs, warnBeforeMs, onIdle, onWarning, onActivity, storageKey, clearTimers]);
+  const startTracking = useCallback3(() => {
+    if (!enabled) return;
+    setIsTracking(false);
+    setIsIdle(false);
+    setShowWarning(false);
+    setTimeRemaining(idleTimeoutMs);
+    clearTimers();
+    setIsTracking(true);
+    try {
+      if (typeof BroadcastChannel !== "undefined") {
+        channelRef.current = new BroadcastChannel(channelName);
+        channelRef.current.onmessage = (event) => {
+          if (event.data.type === "activity") {
+            lastActivityRef.current = event.data.timestamp;
+            resetActivity();
+          }
+        };
+      }
+    } catch (error) {
+      console.warn("[useInactivityTracker] Failed to set up cross-tab communication:", error);
+    }
+    try {
+      const persistedTime = localStorage.getItem(storageKey);
+      if (persistedTime) {
+        const persistedTimestamp = parseInt(persistedTime, 10);
+        const elapsed = Date.now() - persistedTimestamp;
+        if (elapsed < idleTimeoutMs) {
+          lastActivityRef.current = persistedTimestamp;
+          const remaining = idleTimeoutMs - elapsed;
+          setTimeRemaining(remaining);
+          if (remaining <= warnBeforeMs) {
+            setShowWarning(true);
+            onWarning?.();
+          }
+          if (remaining <= 0) {
+            setIsIdle(true);
+            onIdle?.();
+            return;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("[useInactivityTracker] Failed to check persisted activity time:", error);
+    }
+    const throttledResetActivity = throttle((event) => {
+      resetActivity();
+    }, 100);
+    const addEventListeners = () => {
+      ACTIVITY_EVENTS.forEach((event) => {
+        document.addEventListener(event, throttledResetActivity, { passive: true });
+      });
+    };
+    const removeEventListeners = () => {
+      ACTIVITY_EVENTS.forEach((event) => {
+        document.removeEventListener(event, throttledResetActivity);
+      });
+    };
+    addEventListeners();
+    resetActivity(true);
+    return () => {
+      removeEventListeners();
+      clearTimers();
+      if (channelRef.current) {
+        channelRef.current.close();
+        channelRef.current = null;
+      }
+    };
+  }, [enabled, isTracking, channelName, storageKey, idleTimeoutMs, warnBeforeMs, onIdle, onWarning]);
+  const stopTracking = useCallback3(() => {
+    setIsTracking(false);
+    clearTimers();
+    if (channelRef.current) {
+      channelRef.current.close();
+      channelRef.current = null;
+    }
+  }, [clearTimers]);
+  useEffect3(() => {
+    if (enabled) {
+      const cleanup = startTracking();
+      return cleanup;
+    } else {
+      stopTracking();
+    }
+  }, [enabled, idleTimeoutMs, warnBeforeMs]);
+  useEffect3(() => {
+    return () => {
+      clearTimers();
+      if (channelRef.current) {
+        channelRef.current.close();
+      }
+    };
+  }, [clearTimers]);
+  return {
+    isIdle,
+    timeRemaining,
+    showWarning,
+    resetActivity,
+    startTracking,
+    stopTracking,
+    isTracking
+  };
+}
+var ACTIVITY_EVENTS;
+var init_useInactivityTracker = __esm({
+  "src/hooks/useInactivityTracker.ts"() {
+    "use strict";
+    ACTIVITY_EVENTS = [
+      "mousedown",
+      "mousemove",
+      "mouseup",
+      "click",
+      "scroll",
+      "wheel",
+      "touchstart",
+      "touchmove",
+      "touchend",
+      "keydown",
+      "keyup",
+      "keypress",
+      "focus",
+      "blur",
+      "visibilitychange"
+    ];
+  }
+});
+
 // src/components/Dialog/utils/safeHtml.ts
 function sanitizeHtml(html) {
   if (!html || typeof html !== "string") {
@@ -761,7 +1733,7 @@ var require_lodash = __commonJS({
       }
       var runInContext = (function runInContext2(context) {
         context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));
-        var Array2 = context.Array, Date = context.Date, Error = context.Error, Function2 = context.Function, Math2 = context.Math, Object2 = context.Object, RegExp2 = context.RegExp, String = context.String, TypeError = context.TypeError;
+        var Array2 = context.Array, Date2 = context.Date, Error2 = context.Error, Function2 = context.Function, Math2 = context.Math, Object2 = context.Object, RegExp2 = context.RegExp, String = context.String, TypeError = context.TypeError;
         var arrayProto = Array2.prototype, funcProto = Function2.prototype, objectProto = Object2.prototype;
         var coreJsData = context["__core-js_shared__"];
         var funcToString = funcProto.toString;
@@ -786,8 +1758,8 @@ var require_lodash = __commonJS({
           } catch (e) {
           }
         })();
-        var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, ctxNow = Date && Date.now !== root.Date.now && Date.now, ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
-        var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined2, nativeIsFinite = context.isFinite, nativeJoin = arrayProto.join, nativeKeys = overArg(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date.now, nativeParseInt = context.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto.reverse;
+        var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, ctxNow = Date2 && Date2.now !== root.Date.now && Date2.now, ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
+        var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined2, nativeIsFinite = context.isFinite, nativeJoin = arrayProto.join, nativeKeys = overArg(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date2.now, nativeParseInt = context.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto.reverse;
         var DataView = getNative(context, "DataView"), Map = getNative(context, "Map"), Promise2 = getNative(context, "Promise"), Set = getNative(context, "Set"), WeakMap = getNative(context, "WeakMap"), nativeCreate = getNative(Object2, "create");
         var metaMap = WeakMap && new WeakMap();
         var realNames = {};
@@ -1286,7 +2258,7 @@ var require_lodash = __commonJS({
           if (typeof func != "function") {
             throw new TypeError(FUNC_ERROR_TEXT);
           }
-          return setTimeout(function() {
+          return setTimeout2(function() {
             func.apply(undefined2, args);
           }, wait);
         }
@@ -2066,7 +3038,7 @@ var require_lodash = __commonJS({
           end = end === undefined2 ? length : end;
           return !start && end >= length ? array : baseSlice(array, start, end);
         }
-        var clearTimeout = ctxClearTimeout || function(id) {
+        var clearTimeout2 = ctxClearTimeout || function(id) {
           return root.clearTimeout(id);
         };
         function cloneBuffer(buffer, isDeep) {
@@ -3117,7 +4089,7 @@ var require_lodash = __commonJS({
           return object[key];
         }
         var setData = shortOut(baseSetData);
-        var setTimeout = ctxSetTimeout || function(func, wait) {
+        var setTimeout2 = ctxSetTimeout || function(func, wait) {
           return root.setTimeout(func, wait);
         };
         var setToString = shortOut(baseSetToString);
@@ -3909,7 +4881,7 @@ var require_lodash = __commonJS({
           }
           function leadingEdge(time) {
             lastInvokeTime = time;
-            timerId = setTimeout(timerExpired, wait);
+            timerId = setTimeout2(timerExpired, wait);
             return leading ? invokeFunc(time) : result2;
           }
           function remainingWait(time) {
@@ -3925,7 +4897,7 @@ var require_lodash = __commonJS({
             if (shouldInvoke(time)) {
               return trailingEdge(time);
             }
-            timerId = setTimeout(timerExpired, remainingWait(time));
+            timerId = setTimeout2(timerExpired, remainingWait(time));
           }
           function trailingEdge(time) {
             timerId = undefined2;
@@ -3937,7 +4909,7 @@ var require_lodash = __commonJS({
           }
           function cancel() {
             if (timerId !== undefined2) {
-              clearTimeout(timerId);
+              clearTimeout2(timerId);
             }
             lastInvokeTime = 0;
             lastArgs = lastCallTime = lastThis = timerId = undefined2;
@@ -3955,13 +4927,13 @@ var require_lodash = __commonJS({
                 return leadingEdge(lastCallTime);
               }
               if (maxing) {
-                clearTimeout(timerId);
-                timerId = setTimeout(timerExpired, wait);
+                clearTimeout2(timerId);
+                timerId = setTimeout2(timerExpired, wait);
                 return invokeFunc(lastCallTime);
               }
             }
             if (timerId === undefined2) {
-              timerId = setTimeout(timerExpired, wait);
+              timerId = setTimeout2(timerExpired, wait);
             }
             return result2;
           }
@@ -4059,7 +5031,7 @@ var require_lodash = __commonJS({
             return apply(func, this, otherArgs);
           });
         }
-        function throttle(func, wait, options) {
+        function throttle2(func, wait, options) {
           var leading = true, trailing = true;
           if (typeof func != "function") {
             throw new TypeError(FUNC_ERROR_TEXT);
@@ -4204,7 +5176,7 @@ var require_lodash = __commonJS({
         }
         function isNative(value) {
           if (isMaskable(value)) {
-            throw new Error(CORE_ERROR_TEXT);
+            throw new Error2(CORE_ERROR_TEXT);
           }
           return baseIsNative(value);
         }
@@ -4745,7 +5717,7 @@ var require_lodash = __commonJS({
           if (!variable) {
             source = "with (obj) {\n" + source + "\n}\n";
           } else if (reForbiddenIdentifierChars.test(variable)) {
-            throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);
+            throw new Error2(INVALID_TEMPL_VAR_ERROR_TEXT);
           }
           source = (isEvaluating ? source.replace(reEmptyStringLeading, "") : source).replace(reEmptyStringMiddle, "$1").replace(reEmptyStringTrailing, "$1;");
           source = "function(" + (variable || "obj") + ") {\n" + (variable ? "" : "obj || (obj = {});\n") + "var __t, __p = ''" + (isEscaping ? ", __e = _.escape" : "") + (isEvaluating ? ", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n" : ";\n") + source + "return __p\n}";
@@ -4864,7 +5836,7 @@ var require_lodash = __commonJS({
           try {
             return apply(func, undefined2, args);
           } catch (e) {
-            return isError(e) ? e : new Error(e);
+            return isError(e) ? e : new Error2(e);
           }
         });
         var bindAll = flatRest(function(object, methodNames) {
@@ -5176,7 +6148,7 @@ var require_lodash = __commonJS({
         lodash.takeRightWhile = takeRightWhile;
         lodash.takeWhile = takeWhile;
         lodash.tap = tap;
-        lodash.throttle = throttle;
+        lodash.throttle = throttle2;
         lodash.thru = thru;
         lodash.toArray = toArray;
         lodash.toPairs = toPairs;
@@ -5551,11 +6523,11 @@ var require_lodash = __commonJS({
 });
 
 // src/components/Dialog/Dialog.tsx
-import * as React from "react";
+import * as React3 from "react";
 import * as DialogPrimitive from "@radix-ui/react-dialog";
 import { X } from "lucide-react";
-import { useState, useEffect } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { useState as useState4, useEffect as useEffect4 } from "react";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
 var import_lodash, sizeClasses, Dialog, DialogTrigger, DialogPortal, DialogClose, DialogOverlay, useSmartDimensions, DialogContent, DialogHeader, DialogBody, DialogFooter, DialogTitle, DialogDescription;
 var init_Dialog = __esm({
   "src/components/Dialog/Dialog.tsx"() {
@@ -5575,7 +6547,7 @@ var init_Dialog = __esm({
     DialogTrigger = DialogPrimitive.Trigger;
     DialogPortal = DialogPrimitive.Portal;
     DialogClose = DialogPrimitive.Close;
-    DialogOverlay = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+    DialogOverlay = React3.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx3(
       DialogPrimitive.Overlay,
       {
         ref,
@@ -5596,8 +6568,8 @@ var init_Dialog = __esm({
       minWidth,
       enableScrolling = false
     }) => {
-      const [dimensions, setDimensions] = useState({});
-      useEffect(() => {
+      const [dimensions, setDimensions] = useState4({});
+      useEffect4(() => {
         if (!maxHeightPercent && !maxWidthPercent && !maxHeight && !maxWidth && !minHeight && !minWidth) {
           return;
         }
@@ -5652,7 +6624,7 @@ var init_Dialog = __esm({
       }
       return result;
     };
-    DialogContent = React.forwardRef(({
+    DialogContent = React3.forwardRef(({
       className,
       children,
       size = "md",
@@ -5679,17 +6651,17 @@ var init_Dialog = __esm({
         minWidth,
         enableScrolling
       });
-      const handleEscapeKeyDown = React.useCallback((event) => {
+      const handleEscapeKeyDown = React3.useCallback((event) => {
         if (preventCloseOnEscape) {
           event.preventDefault();
         }
       }, [preventCloseOnEscape]);
-      const handlePointerDownOutside = React.useCallback((event) => {
+      const handlePointerDownOutside = React3.useCallback((event) => {
         if (preventCloseOnOutsideClick) {
           event.preventDefault();
         }
       }, [preventCloseOnOutsideClick]);
-      const mergedStyle = React.useMemo(() => {
+      const mergedStyle = React3.useMemo(() => {
         if (Object.keys(smartDimensions).length === 0) {
           return style;
         }
@@ -5701,7 +6673,7 @@ var init_Dialog = __esm({
         return finalStyle;
       }, [smartDimensions, style, maxWidth, maxWidthPercent]);
       return /* @__PURE__ */ jsxs(DialogPortal, { children: [
-        /* @__PURE__ */ jsx(DialogOverlay, { className: overlayClassName }),
+        /* @__PURE__ */ jsx3(DialogOverlay, { className: overlayClassName }),
         /* @__PURE__ */ jsxs(
           DialogPrimitive.Content,
           {
@@ -5731,8 +6703,8 @@ var init_Dialog = __esm({
             children: [
               children,
               showCloseButton && /* @__PURE__ */ jsxs(DialogPrimitive.Close, { className: "absolute right-4 top-4 z-10 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground", children: [
-                /* @__PURE__ */ jsx(X, { className: "h-4 w-4" }),
-                /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Close" })
+                /* @__PURE__ */ jsx3(X, { className: "h-4 w-4" }),
+                /* @__PURE__ */ jsx3("span", { className: "sr-only", children: "Close" })
               ] })
             ]
           }
@@ -5744,7 +6716,7 @@ var init_Dialog = __esm({
       className,
       sticky = false,
       ...props
-    }) => /* @__PURE__ */ jsx(
+    }) => /* @__PURE__ */ jsx3(
       "header",
       {
         className: cn(
@@ -5767,13 +6739,13 @@ var init_Dialog = __esm({
       children,
       ...props
     }) => {
-      const mergedStyle = React.useMemo(() => {
+      const mergedStyle = React3.useMemo(() => {
         return {
           ...maxHeight && { maxHeight },
           ...style
         };
       }, [maxHeight, style]);
-      const processedHtmlContent = React.useMemo(() => {
+      const processedHtmlContent = React3.useMemo(() => {
         if (!htmlContent || !allowHtml) {
           return null;
         }
@@ -5794,7 +6766,7 @@ var init_Dialog = __esm({
         });
         return result.html;
       }, [htmlContent, allowHtml, strictSanitization, logWarnings]);
-      return /* @__PURE__ */ jsx(
+      return /* @__PURE__ */ jsx3(
         "main",
         {
           className: cn(
@@ -5805,14 +6777,14 @@ var init_Dialog = __esm({
           "aria-label": "Dialog main content",
           tabIndex: -1,
           ...props,
-          children: processedHtmlContent ? /* @__PURE__ */ jsx(
+          children: processedHtmlContent ? /* @__PURE__ */ jsx3(
             "div",
             {
               dangerouslySetInnerHTML: { __html: processedHtmlContent },
               className: "prose prose-sm max-w-none"
             }
           ) : /* @__PURE__ */ jsxs("div", { children: [
-            /* @__PURE__ */ jsx("div", { className: "text-red-500 mb-2", children: "No HTML content processed. Showing children instead." }),
+            /* @__PURE__ */ jsx3("div", { className: "text-red-500 mb-2", children: "No HTML content processed. Showing children instead." }),
             children
           ] })
         }
@@ -5823,7 +6795,7 @@ var init_Dialog = __esm({
       className,
       sticky = false,
       ...props
-    }) => /* @__PURE__ */ jsx(
+    }) => /* @__PURE__ */ jsx3(
       "footer",
       {
         className: cn(
@@ -5835,8 +6807,8 @@ var init_Dialog = __esm({
       }
     );
     DialogFooter.displayName = "DialogFooter";
-    DialogTitle = React.forwardRef(({ className, htmlContent, allowHtml = true, children, ...props }, ref) => {
-      const processedHtmlContent = React.useMemo(() => {
+    DialogTitle = React3.forwardRef(({ className, htmlContent, allowHtml = true, children, ...props }, ref) => {
+      const processedHtmlContent = React3.useMemo(() => {
         if (!htmlContent || !allowHtml) {
           return null;
         }
@@ -5846,7 +6818,7 @@ var init_Dialog = __esm({
         });
         return result.html;
       }, [htmlContent, allowHtml]);
-      return /* @__PURE__ */ jsx(
+      return /* @__PURE__ */ jsx3(
         DialogPrimitive.Title,
         {
           ref,
@@ -5855,13 +6827,13 @@ var init_Dialog = __esm({
             className
           ),
           ...props,
-          children: processedHtmlContent ? /* @__PURE__ */ jsx("span", { dangerouslySetInnerHTML: { __html: processedHtmlContent } }) : children
+          children: processedHtmlContent ? /* @__PURE__ */ jsx3("span", { dangerouslySetInnerHTML: { __html: processedHtmlContent } }) : children
         }
       );
     });
     DialogTitle.displayName = DialogPrimitive.Title.displayName;
-    DialogDescription = React.forwardRef(({ className, htmlContent, allowHtml = true, children, ...props }, ref) => {
-      const processedHtmlContent = React.useMemo(() => {
+    DialogDescription = React3.forwardRef(({ className, htmlContent, allowHtml = true, children, ...props }, ref) => {
+      const processedHtmlContent = React3.useMemo(() => {
         if (!htmlContent || !allowHtml) {
           return null;
         }
@@ -5871,13 +6843,13 @@ var init_Dialog = __esm({
         });
         return result.html;
       }, [htmlContent, allowHtml]);
-      return /* @__PURE__ */ jsx(
+      return /* @__PURE__ */ jsx3(
         DialogPrimitive.Description,
         {
           ref,
           className: cn("text-sm text-muted-foreground", className),
           ...props,
-          children: processedHtmlContent ? /* @__PURE__ */ jsx("span", { dangerouslySetInnerHTML: { __html: processedHtmlContent } }) : children
+          children: processedHtmlContent ? /* @__PURE__ */ jsx3("span", { dangerouslySetInnerHTML: { __html: processedHtmlContent } }) : children
         }
       );
     });
@@ -5886,9 +6858,9 @@ var init_Dialog = __esm({
 });
 
 // src/components/Tooltip/Tooltip.tsx
-import * as React2 from "react";
+import * as React4 from "react";
 import * as TooltipPrimitive from "@radix-ui/react-tooltip";
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
 var TooltipProvider, TooltipRoot, TooltipTrigger, TooltipContent, Tooltip;
 var init_Tooltip = __esm({
   "src/components/Tooltip/Tooltip.tsx"() {
@@ -5897,7 +6869,7 @@ var init_Tooltip = __esm({
     TooltipProvider = TooltipPrimitive.Provider;
     TooltipRoot = TooltipPrimitive.Root;
     TooltipTrigger = TooltipPrimitive.Trigger;
-    TooltipContent = React2.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx2(
+    TooltipContent = React4.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx4(
       TooltipPrimitive.Content,
       {
         ref,
@@ -5910,9 +6882,9 @@ var init_Tooltip = __esm({
       }
     ));
     TooltipContent.displayName = TooltipPrimitive.Content.displayName;
-    Tooltip = React2.forwardRef(({ children, content, delayDuration = 200 }, ref) => /* @__PURE__ */ jsx2(TooltipProvider, { children: /* @__PURE__ */ jsxs2(TooltipRoot, { delayDuration, children: [
-      /* @__PURE__ */ jsx2(TooltipTrigger, { ref, asChild: true, children: /* @__PURE__ */ jsx2("span", { children }) }),
-      /* @__PURE__ */ jsx2(TooltipContent, { children: content })
+    Tooltip = React4.forwardRef(({ children, content, delayDuration = 200 }, ref) => /* @__PURE__ */ jsx4(TooltipProvider, { children: /* @__PURE__ */ jsxs2(TooltipRoot, { delayDuration, children: [
+      /* @__PURE__ */ jsx4(TooltipTrigger, { ref, asChild: true, children: /* @__PURE__ */ jsx4("span", { children }) }),
+      /* @__PURE__ */ jsx4(TooltipContent, { children: content })
     ] }) }));
     Tooltip.displayName = "Tooltip";
   }
@@ -5927,9 +6899,9 @@ var init_Tooltip2 = __esm({
 });
 
 // src/components/Button/Button.tsx
-import * as React3 from "react";
+import * as React5 from "react";
 import { Slot } from "@radix-ui/react-slot";
-import { jsx as jsx3 } from "react/jsx-runtime";
+import { jsx as jsx5 } from "react/jsx-runtime";
 function getButtonClasses(variant = "default", size = "default") {
   const baseClasses = "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50";
   const variantClasses = {
@@ -5954,10 +6926,10 @@ var init_Button = __esm({
     "use strict";
     init_cn();
     init_Tooltip2();
-    Button = React3.forwardRef(
+    Button = React5.forwardRef(
       ({ className, variant, size, asChild = false, type = "button", disabled, ...props }, ref) => {
         const Comp = asChild ? Slot : "button";
-        return /* @__PURE__ */ jsx3(
+        return /* @__PURE__ */ jsx5(
           Comp,
           {
             className: cn(getButtonClasses(variant, size), className),
@@ -5971,9 +6943,9 @@ var init_Button = __esm({
       }
     );
     Button.displayName = "Button";
-    IconButton = React3.forwardRef(
+    IconButton = React5.forwardRef(
       ({ icon, className, size = "icon", "aria-label": ariaLabel, tooltip, ...props }, ref) => {
-        const button = /* @__PURE__ */ jsx3(
+        const button = /* @__PURE__ */ jsx5(
           Button,
           {
             ref,
@@ -5985,7 +6957,7 @@ var init_Button = __esm({
           }
         );
         if (tooltip) {
-          return /* @__PURE__ */ jsx3(Tooltip, { content: tooltip, children: button });
+          return /* @__PURE__ */ jsx5(Tooltip, { content: tooltip, children: button });
         }
         return button;
       }
@@ -5994,7 +6966,390 @@ var init_Button = __esm({
   }
 });
 
+// src/components/InactivityWarningModal/InactivityWarningModal.tsx
+import { useEffect as useEffect5, useState as useState5, useCallback as useCallback5 } from "react";
+import { Clock, AlertTriangle } from "lucide-react";
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function InactivityWarningModal({
+  isOpen,
+  timeRemaining,
+  onStaySignedIn,
+  onSignOutNow,
+  title = "Session Timeout Warning",
+  description = "You've been inactive for a while. Your session will expire soon for security reasons.",
+  className
+}) {
+  const [displayTime, setDisplayTime] = useState5(timeRemaining);
+  useEffect5(() => {
+    setDisplayTime(timeRemaining);
+  }, [timeRemaining]);
+  const formatTime = useCallback5((seconds) => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+  }, []);
+  return /* @__PURE__ */ jsx6(Dialog, { open: isOpen, onOpenChange: (open) => !open && onStaySignedIn(), children: /* @__PURE__ */ jsxs3(
+    DialogContent,
+    {
+      className: `sm:max-w-md ${className || ""}`,
+      preventCloseOnEscape: false,
+      preventCloseOnOutsideClick: true,
+      "data-testid": "inactivity-warning-modal",
+      children: [
+        /* @__PURE__ */ jsxs3(DialogHeader, { children: [
+          /* @__PURE__ */ jsxs3("div", { className: "flex items-center gap-3", children: [
+            /* @__PURE__ */ jsx6("div", { className: "flex-shrink-0", children: /* @__PURE__ */ jsx6(AlertTriangle, { className: "h-6 w-6 text-acc-600" }) }),
+            /* @__PURE__ */ jsx6("div", { children: /* @__PURE__ */ jsx6(DialogTitle, { className: "text-lg font-semibold text-main-900", children: title }) })
+          ] }),
+          /* @__PURE__ */ jsx6(DialogDescription, { className: "text-main-700 mt-2", children: description })
+        ] }),
+        /* @__PURE__ */ jsxs3("div", { className: "space-y-6", children: [
+          /* @__PURE__ */ jsxs3("div", { className: "text-center", children: [
+            /* @__PURE__ */ jsxs3("div", { className: "inline-flex items-center gap-2 px-4 py-3 bg-acc-50 border border-acc-200 rounded-lg", children: [
+              /* @__PURE__ */ jsx6(Clock, { className: "h-5 w-5 text-acc-600" }),
+              /* @__PURE__ */ jsx6("span", { className: "text-2xl font-mono font-bold text-acc-700", children: formatTime(displayTime) })
+            ] }),
+            /* @__PURE__ */ jsx6("p", { className: "text-sm text-main-600 mt-2", children: "Time remaining before automatic logout" })
+          ] }),
+          /* @__PURE__ */ jsxs3("div", { className: "flex flex-col sm:flex-row gap-3", children: [
+            /* @__PURE__ */ jsx6(
+              Button,
+              {
+                onClick: onStaySignedIn,
+                className: "flex-1 bg-main-600 hover:bg-main-700 text-main-50",
+                size: "lg",
+                children: "Stay Signed In"
+              }
+            ),
+            /* @__PURE__ */ jsx6(
+              Button,
+              {
+                onClick: onSignOutNow,
+                variant: "outline",
+                className: "flex-1 border-acc-300 text-acc-700 hover:bg-acc-50",
+                size: "lg",
+                children: "Sign Out Now"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx6("div", { className: "text-xs text-main-500 text-center", children: /* @__PURE__ */ jsx6("p", { children: "For security reasons, you'll be automatically signed out after 30 minutes of inactivity." }) })
+        ] })
+      ]
+    }
+  ) });
+}
+var init_InactivityWarningModal = __esm({
+  "src/components/InactivityWarningModal/InactivityWarningModal.tsx"() {
+    "use strict";
+    init_Dialog();
+    init_Button();
+  }
+});
+
+// src/providers/InactivityProvider.tsx
+import { createContext as createContext3, useContext as useContext3, useState as useState6, useEffect as useEffect6, useCallback as useCallback6, useMemo as useMemo4 } from "react";
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+function InactivityProvider({
+  children,
+  user,
+  session,
+  supabaseClient,
+  idleTimeoutMs = 30 * 60 * 1e3,
+  // 30 minutes
+  warnBeforeMs = 60 * 1e3,
+  // 60 seconds
+  onIdleLogout,
+  renderInactivityWarning,
+  dangerouslyDisableInactivity = false
+}) {
+  const [showInactivityWarning, setShowInactivityWarning] = useState6(false);
+  const [inactivityTimeRemaining, setInactivityTimeRemaining] = useState6(0);
+  useEffect6(() => {
+    if (typeof window !== "undefined") {
+      const isProduction = true;
+      if (isProduction && dangerouslyDisableInactivity) {
+        console.error("[InactivityProvider] CRITICAL: dangerouslyDisableInactivity is not allowed in production! Auto-enabling inactivity feature.");
+      }
+      if (!isProduction && dangerouslyDisableInactivity) {
+        console.warn("[InactivityProvider] Inactivity feature disabled for development. This will NOT work in production.");
+      }
+    }
+  }, [dangerouslyDisableInactivity]);
+  const isInactivityEnabled = typeof window !== "undefined" && (false ? !dangerouslyDisableInactivity : true);
+  const {
+    isIdle,
+    timeRemaining,
+    showWarning,
+    resetActivity,
+    startTracking,
+    stopTracking,
+    isTracking
+  } = useInactivityTracker({
+    idleTimeoutMs,
+    warnBeforeMs,
+    enabled: isInactivityEnabled && !!user && !!session,
+    onIdle: useCallback6(() => {
+      setShowInactivityWarning(false);
+      setInactivityTimeRemaining(0);
+      if (supabaseClient) {
+        supabaseClient.auth.signOut().catch((error) => {
+          console.error("[InactivityProvider] Error during idle logout:", error);
+        });
+      }
+      onIdleLogout?.("inactivity");
+    }, [supabaseClient, onIdleLogout]),
+    onWarning: useCallback6(() => {
+      setShowInactivityWarning(true);
+      setInactivityTimeRemaining(warnBeforeMs);
+    }, [warnBeforeMs]),
+    onActivity: useCallback6(() => {
+      setShowInactivityWarning(false);
+      setInactivityTimeRemaining(0);
+    }, [])
+  });
+  const handleIdleLogout = useCallback6(async () => {
+    setShowInactivityWarning(false);
+    setInactivityTimeRemaining(0);
+    stopTracking();
+    try {
+      if (supabaseClient) {
+        await supabaseClient.auth.signOut();
+      }
+    } catch (error) {
+      console.error("[InactivityProvider] Error during idle logout:", error);
+    }
+    onIdleLogout?.("inactivity");
+  }, [supabaseClient, onIdleLogout, stopTracking]);
+  const handleStaySignedIn = useCallback6(() => {
+    setShowInactivityWarning(false);
+    setInactivityTimeRemaining(0);
+    resetActivity();
+  }, [resetActivity]);
+  const handleSignOutNow = useCallback6(async () => {
+    setShowInactivityWarning(false);
+    setInactivityTimeRemaining(0);
+    stopTracking();
+    try {
+      if (supabaseClient) {
+        await supabaseClient.auth.signOut();
+      }
+    } catch (error) {
+      console.error("[InactivityProvider] Error during manual sign out:", error);
+    }
+    onIdleLogout?.("inactivity");
+  }, [supabaseClient, onIdleLogout, stopTracking]);
+  useEffect6(() => {
+    if (showWarning && timeRemaining > 0) {
+      setInactivityTimeRemaining(Math.ceil(timeRemaining / 1e3));
+    }
+  }, [showWarning, timeRemaining]);
+  const contextValue = useMemo4(() => ({
+    showInactivityWarning,
+    inactivityTimeRemaining,
+    isIdle,
+    timeRemaining,
+    showWarning,
+    isTracking,
+    resetActivity,
+    startTracking,
+    stopTracking,
+    handleIdleLogout,
+    handleStaySignedIn,
+    handleSignOutNow
+  }), [
+    showInactivityWarning,
+    inactivityTimeRemaining,
+    isIdle,
+    timeRemaining,
+    showWarning,
+    isTracking,
+    resetActivity,
+    startTracking,
+    stopTracking,
+    handleIdleLogout,
+    handleStaySignedIn,
+    handleSignOutNow
+  ]);
+  return /* @__PURE__ */ jsxs4(InactivityContext.Provider, { value: contextValue, children: [
+    children,
+    showInactivityWarning && (renderInactivityWarning ? renderInactivityWarning({
+      timeRemaining: inactivityTimeRemaining,
+      onStaySignedIn: handleStaySignedIn,
+      onSignOutNow: handleSignOutNow
+    }) : /* @__PURE__ */ jsx7(
+      InactivityWarningModal,
+      {
+        isOpen: showInactivityWarning,
+        timeRemaining: inactivityTimeRemaining,
+        onStaySignedIn: handleStaySignedIn,
+        onSignOutNow: handleSignOutNow
+      }
+    ))
+  ] });
+}
+var InactivityContext, useInactivity;
+var init_InactivityProvider = __esm({
+  "src/providers/InactivityProvider.tsx"() {
+    "use strict";
+    init_useInactivityTracker();
+    init_InactivityWarningModal();
+    InactivityContext = createContext3(void 0);
+    useInactivity = () => {
+      const context = useContext3(InactivityContext);
+      if (!context) {
+        throw new Error("useInactivity must be used within an InactivityProvider");
+      }
+      return context;
+    };
+  }
+});
+
+// src/providers/UnifiedAuthProvider.tsx
+var UnifiedAuthProvider_exports = {};
+__export(UnifiedAuthProvider_exports, {
+  UnifiedAuthProvider: () => UnifiedAuthProvider,
+  useUnifiedAuth: () => useUnifiedAuth
+});
+import { createContext as createContext4, useContext as useContext4, useMemo as useMemo5 } from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+function UnifiedAuthContextProvider({
+  children,
+  appName,
+  ...props
+}) {
+  const auth = useAuth();
+  const rbac = useRBAC();
+  const inactivity = useInactivity();
+  const contextValue = useMemo5(() => ({
+    ...auth,
+    ...rbac,
+    ...inactivity,
+    appName,
+    isLoading: auth.authLoading || rbac.rbacLoading,
+    hasErrors: !!auth.authError || !!rbac.rbacError
+  }), [auth, rbac, inactivity, appName]);
+  return /* @__PURE__ */ jsx8(UnifiedAuthContext.Provider, { value: contextValue, children });
+}
+function AuthAwareProviders({
+  children,
+  supabaseClient,
+  appName,
+  persistState,
+  enablePersistence,
+  requireOrganisationContext,
+  enableRBAC,
+  idleTimeoutMs,
+  warnBeforeMs,
+  onIdleLogout,
+  renderInactivityWarning,
+  dangerouslyDisableInactivity
+}) {
+  const auth = useAuth();
+  return /* @__PURE__ */ jsx8(
+    RBACProvider,
+    {
+      supabaseClient,
+      user: auth.user,
+      session: auth.session,
+      appName,
+      enableRBAC,
+      persistState,
+      enablePersistence,
+      requireOrganisationContext,
+      children: /* @__PURE__ */ jsx8(
+        InactivityProvider,
+        {
+          user: auth.user,
+          session: auth.session,
+          supabaseClient,
+          idleTimeoutMs,
+          warnBeforeMs,
+          onIdleLogout,
+          renderInactivityWarning,
+          dangerouslyDisableInactivity,
+          children: /* @__PURE__ */ jsx8(
+            UnifiedAuthContextProvider,
+            {
+              appName,
+              supabaseClient,
+              persistState,
+              enablePersistence,
+              requireOrganisationContext,
+              enableRBAC,
+              idleTimeoutMs,
+              warnBeforeMs,
+              onIdleLogout,
+              renderInactivityWarning,
+              dangerouslyDisableInactivity,
+              children
+            }
+          )
+        }
+      )
+    }
+  );
+}
+function UnifiedAuthProvider({
+  children,
+  supabaseClient,
+  appName,
+  persistState = true,
+  enablePersistence,
+  requireOrganisationContext = true,
+  enableRBAC = false,
+  idleTimeoutMs = 30 * 60 * 1e3,
+  // 30 minutes
+  warnBeforeMs = 60 * 1e3,
+  // 60 seconds
+  onIdleLogout,
+  renderInactivityWarning,
+  dangerouslyDisableInactivity = false
+}) {
+  return /* @__PURE__ */ jsx8(AuthProvider, { supabaseClient, children: /* @__PURE__ */ jsx8(
+    AuthAwareProviders,
+    {
+      supabaseClient,
+      appName,
+      persistState,
+      enablePersistence,
+      requireOrganisationContext,
+      enableRBAC,
+      idleTimeoutMs,
+      warnBeforeMs,
+      onIdleLogout,
+      renderInactivityWarning,
+      dangerouslyDisableInactivity,
+      children
+    }
+  ) });
+}
+var UnifiedAuthContext, useUnifiedAuth;
+var init_UnifiedAuthProvider = __esm({
+  "src/providers/UnifiedAuthProvider.tsx"() {
+    "use strict";
+    init_AuthProvider();
+    init_RBACProvider();
+    init_InactivityProvider();
+    UnifiedAuthContext = createContext4(void 0);
+    useUnifiedAuth = () => {
+      const context = useContext4(UnifiedAuthContext);
+      if (!context) {
+        throw new Error("useUnifiedAuth must be used within a UnifiedAuthProvider");
+      }
+      return context;
+    };
+  }
+});
+
 export {
+  useAuth,
+  AuthProvider,
+  init_AuthProvider,
+  useRBAC,
+  RBACProvider,
+  init_RBACProvider,
+  useInactivityTracker,
+  init_useInactivityTracker,
   Dialog,
   DialogTrigger,
   DialogPortal,
@@ -6015,7 +7370,16 @@ export {
   init_Tooltip,
   init_Tooltip2,
   Button,
-  init_Button
+  init_Button,
+  InactivityWarningModal,
+  init_InactivityWarningModal,
+  useInactivity,
+  InactivityProvider,
+  init_InactivityProvider,
+  useUnifiedAuth,
+  UnifiedAuthProvider,
+  UnifiedAuthProvider_exports,
+  init_UnifiedAuthProvider
 };
 /*! Bundled license information:
 
@@ -6029,4 +7393,4 @@ lodash/lodash.js:
    * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
    *)
 */
-//# sourceMappingURL=chunk-ETEJVKYK.js.map
+//# sourceMappingURL=chunk-6CR3MRZN.js.map