@jmruthers/pace-core 0.5.193 → 0.6.2

package/dist/{chunk-XNXXZ43G.js → chunk-XWQCNGTQ.js}

@@ -1,13 +1,12 @@
 import {
   useAppConfig,
   useEvents,
-  useOrganisationSecurity,
-  useResolvedScope
-} from "./chunk-IIELH4DL.js";
+  useOrganisationSecurity
+} from "./chunk-MMZ7JXPU.js";
 import {
   useOrganisations,
   useUnifiedAuth
-} from "./chunk-7FLMSG37.js";
+} from "./chunk-EHMR7VYL.js";
 import {
   ContextValidator,
   OrganisationContextRequiredError,
@@ -18,31 +17,41 @@ import {
   isPermitted,
   isPermittedCached,
   resolveAppContext
-} from "./chunk-KNC55RTG.js";
+} from "./chunk-24UVZUZG.js";
 import {
+  getCurrentAppName
+} from "./chunk-F2IMUDXZ.js";
+import {
+  createLogger,
   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, isSuperAdmin = false) {
+var _SecureSupabaseClient = class _SecureSupabaseClient {
+  constructor(supabaseUrl, supabaseKey, organisationId, eventId, appId, isSuperAdmin = false, existingClient) {
     this.edgeFunctionClient = null;
+    this.usesExistingClient = false;
     this.supabaseUrl = supabaseUrl;
     this.supabaseKey = supabaseKey;
     this.organisationId = organisationId;
     this.eventId = eventId;
     this.appId = appId;
     this.isSuperAdmin = isSuperAdmin;
-    this.supabase = createClient(supabaseUrl, supabaseKey, {
-      global: {
-        headers: {
-          "x-organisation-id": organisationId,
-          "x-event-id": eventId || "",
-          "x-app-id": appId || ""
+    if (existingClient) {
+      this.supabase = existingClient;
+      this.usesExistingClient = true;
+    } else {
+      this.supabase = createClient(supabaseUrl, supabaseKey, {
+        global: {
+          headers: {
+            "x-organisation-id": organisationId || "",
+            "x-event-id": eventId || "",
+            "x-app-id": appId || ""
+          }
         }
-      }
-    });
+      });
+    }
     this.setupContextInjection();
     this.setupEdgeFunctionHandling();
   }
@@ -52,19 +61,20 @@ var SecureSupabaseClient = class _SecureSupabaseClient {
   setupContextInjection() {
     const originalFrom = this.supabase.from.bind(this.supabase);
     this.supabase.from = (table) => {
-      this.validateContext();
+      this.validateContextForTable(table);
       const query = originalFrom(table);
       query._tableName = table;
       return this.injectContext(query, table);
     };
     const originalRpc = this.supabase.rpc.bind(this.supabase);
     this.supabase.rpc = (fn, args, options) => {
-      this.validateContext();
+      this.validateContextForRpc(fn);
+      const safeArgs = args ?? {};
       const contextArgs = {
-        ...args,
-        p_organisation_id: this.organisationId,
-        p_event_id: this.eventId,
-        p_app_id: this.appId
+        ...safeArgs,
+        ...this.organisationId && safeArgs.p_organisation_id === void 0 ? { p_organisation_id: this.organisationId } : {},
+        ...this.eventId && safeArgs.p_event_id === void 0 ? { p_event_id: this.eventId } : {},
+        ...this.appId && safeArgs.p_app_id === void 0 ? { p_app_id: this.appId } : {}
       };
       return originalRpc(fn, contextArgs, options);
     };
@@ -79,6 +89,10 @@ var SecureSupabaseClient = class _SecureSupabaseClient {
    * This avoids interfering with the main client's operations.
    */
   setupEdgeFunctionHandling() {
+    if (this.usesExistingClient) {
+      this.edgeFunctionClient = null;
+      return;
+    }
     this.edgeFunctionClient = createClient(this.supabaseUrl, this.supabaseKey);
   }
   /**
@@ -119,9 +133,18 @@ var SecureSupabaseClient = class _SecureSupabaseClient {
         if (this.isSuperAdmin) {
           return originalInsert(values);
         }
+        if (!this.organisationId) {
+          throw new OrganisationContextRequiredError();
+        }
         const contextValues2 = Array.isArray(values) ? values.map((v) => ({ ...v, organisation_id: this.organisationId })) : { ...values, organisation_id: this.organisationId };
         return originalInsert(contextValues2);
       }
+      if (this.isSuperAdmin && !this.organisationId) {
+        return originalInsert(values);
+      }
+      if (!this.organisationId) {
+        throw new OrganisationContextRequiredError();
+      }
       const contextValues = Array.isArray(values) ? values.map((v) => ({ ...v, organisation_id: this.organisationId })) : { ...values, organisation_id: this.organisationId };
       return originalInsert(contextValues);
     };
@@ -146,6 +169,10 @@ var SecureSupabaseClient = class _SecureSupabaseClient {
    * - Super admins: No org filter (see all users) - RLS will allow access
    * - Non-super-admins: Apply org filter as defense in depth - RLS will also filter
    * 
+   * For system-wide tables (like core_organisations):
+   * - Super admins: No org filter (see all records) - RLS will allow access
+   * - Non-super-admins: Apply org filter as defense in depth - RLS will also filter
+   * 
    * For other tables:
    * - Always apply org filter unless super admin bypasses it
    */
@@ -157,8 +184,31 @@ var SecureSupabaseClient = class _SecureSupabaseClient {
       // App configuration table - no organisation scope
       "rbac_app_pages",
       // Page configuration table - scoped by app_id, not organisation_id
-      "rbac_global_roles"
+      "rbac_global_roles",
       // Global roles - no organisation scope
+      // Person-scoped tables (organisation_id was removed in person-scoped profiles migration)
+      "core_person",
+      // Person records - person-scoped, no organisation_id
+      "core_member",
+      // Member profiles - person-scoped, no organisation_id
+      "core_contact",
+      // Contact profiles - person-scoped, no organisation_id
+      "core_consent",
+      // Consent records - person-scoped, no organisation_id
+      "core_identification",
+      // Identification records - person-scoped, no organisation_id
+      "core_qualification",
+      // Qualification records - person-scoped, no organisation_id
+      "medi_profile",
+      // Medical profiles - person-scoped, no organisation_id
+      "medi_condition",
+      // Medical conditions - person-scoped via medi_profile, no organisation_id
+      "medi_diet",
+      // Medical diets - person-scoped via medi_profile, no organisation_id
+      "medi_action_plan",
+      // Medical action plans - person-scoped via medi_profile, no organisation_id
+      "medi_profile_versions"
+      // Medical profile versions - person-scoped via medi_profile, no organisation_id
     ];
     if (tablesWithoutOrganisationId.includes(tableName)) {
       return query;
@@ -166,6 +216,13 @@ var SecureSupabaseClient = class _SecureSupabaseClient {
     if (!this.organisationId) {
       return query;
     }
+    const systemWideTablesForSuperAdmins = [
+      "core_organisations"
+      // Super-admins need to see all organisations
+    ];
+    if (systemWideTablesForSuperAdmins.includes(tableName) && this.isSuperAdmin) {
+      return query;
+    }
     if (tableName === "rbac_user_profiles") {
       if (this.isSuperAdmin) {
         return query;
@@ -179,12 +236,57 @@ var SecureSupabaseClient = class _SecureSupabaseClient {
   }
   /**
    * Validate that required context is present
+   * Super-admins can operate without organisation context
    */
   validateContext() {
+    if (this.isSuperAdmin) {
+      return;
+    }
     if (!this.organisationId) {
       throw new OrganisationContextRequiredError();
     }
   }
+  /**
+   * Determine whether a table requires organisation context.
+   * Tables without an organisation_id column (or global configuration tables) are safe without org context.
+   */
+  tableRequiresOrganisationContext(tableName) {
+    const tablesWithoutOrganisationId = /* @__PURE__ */ new Set([
+      "core_organisations",
+      "rbac_apps",
+      "rbac_app_pages",
+      "rbac_global_roles",
+      "core_person",
+      "core_member",
+      "core_contact",
+      "core_consent",
+      "core_identification",
+      "core_qualification",
+      "medi_profile",
+      "medi_condition",
+      "medi_diet",
+      "medi_action_plan",
+      "medi_profile_versions"
+    ]);
+    return !tablesWithoutOrganisationId.has(tableName);
+  }
+  /**
+   * Validate context for a specific table operation.
+   */
+  validateContextForTable(tableName) {
+    if (this.isSuperAdmin) return;
+    if (!this.organisationId && this.tableRequiresOrganisationContext(tableName)) {
+      throw new OrganisationContextRequiredError();
+    }
+  }
+  /**
+   * Validate context for a specific RPC call.
+   */
+  validateContextForRpc(fn) {
+    if (this.isSuperAdmin) return;
+    if (_SecureSupabaseClient.GLOBAL_RPC_ALLOWLIST.has(fn)) return;
+    this.validateContext();
+  }
   /**
    * Get the current organisation ID
    */
@@ -210,7 +312,7 @@ var SecureSupabaseClient = class _SecureSupabaseClient {
     return new _SecureSupabaseClient(
       this.supabaseUrl,
       this.supabaseKey,
-      updates.organisationId || this.organisationId,
+      updates.organisationId !== void 0 ? updates.organisationId : this.organisationId,
       updates.eventId !== void 0 ? updates.eventId : this.eventId,
       updates.appId !== void 0 ? updates.appId : this.appId,
       updates.isSuperAdmin !== void 0 ? updates.isSuperAdmin : this.isSuperAdmin
@@ -231,15 +333,216 @@ var SecureSupabaseClient = class _SecureSupabaseClient {
     });
   }
 };
+/**
+ * RPC functions that are safe to call without organisation context.
+ *
+ * These functions must:
+ * - rely on JWT context (auth.uid()) for authentication
+ * - not read or write organisation-scoped data
+ *
+ * This allowlist enables compliant consuming apps to use `secureSupabase.rpc(...)`
+ * even before an organisation is selected (common during initial page load/refresh).
+ */
+_SecureSupabaseClient.GLOBAL_RPC_ALLOWLIST = /* @__PURE__ */ new Set([
+  "data_rbac_apps_list"
+]);
+var SecureSupabaseClient = _SecureSupabaseClient;
 function createSecureClient(supabaseUrl, supabaseKey, organisationId, eventId, appId, isSuperAdmin = false) {
   return new SecureSupabaseClient(supabaseUrl, supabaseKey, organisationId, eventId, appId, isSuperAdmin);
 }
-function fromSupabaseClient(client, organisationId, eventId, appId) {
-  throw new Error("fromSupabaseClient is not supported. Use createSecureClient instead.");
+function fromSupabaseClient(client, organisationId, eventId, appId, isSuperAdmin = false) {
+  return new SecureSupabaseClient("", "", organisationId, eventId, appId, isSuperAdmin, client);
+}
+
+// src/rbac/hooks/useResolvedScope.ts
+import { useEffect, useState, useRef, useMemo } from "react";
+var log = createLogger("useResolvedScope");
+var appConfigCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 5 * 60 * 1e3;
+function useResolvedScope({
+  supabase,
+  selectedOrganisationId,
+  selectedEventId
+}) {
+  const [resolvedScope, setResolvedScope] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const stableScopeRef = useRef({
+    organisationId: "",
+    appId: "",
+    eventId: void 0
+  });
+  useEffect(() => {
+    if (resolvedScope) {
+      const newScope = {
+        organisationId: resolvedScope.organisationId || "",
+        appId: resolvedScope.appId || "",
+        eventId: resolvedScope.eventId
+      };
+      if (stableScopeRef.current.organisationId !== newScope.organisationId || stableScopeRef.current.eventId !== newScope.eventId || stableScopeRef.current.appId !== newScope.appId) {
+        stableScopeRef.current = {
+          organisationId: newScope.organisationId,
+          appId: newScope.appId,
+          eventId: newScope.eventId
+        };
+      }
+    } else {
+      stableScopeRef.current = { organisationId: "", appId: "", eventId: void 0 };
+    }
+  }, [resolvedScope]);
+  const appName = getCurrentAppName();
+  const stableScope = stableScopeRef.current;
+  useEffect(() => {
+    let cancelled = false;
+    const resolveScope = async () => {
+      if (!supabase && !selectedOrganisationId && !selectedEventId) {
+        if (!cancelled) {
+          setResolvedScope(null);
+          setIsLoading(false);
+          setError(null);
+        }
+        return;
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        const appName2 = getCurrentAppName();
+        let appId = void 0;
+        let appConfig = null;
+        if (supabase && appName2) {
+          try {
+            const { data: session } = await supabase.auth.getSession();
+            if (!session?.session) {
+              log.debug(`Skipping app resolution for "${appName2}" - user not authenticated`);
+            } else {
+              const cached = appConfigCache.get(appName2);
+              const now = Date.now();
+              if (cached && now - cached.timestamp < CACHE_TTL) {
+                appId = cached.appId;
+                appConfig = cached.appConfig;
+              } else {
+                const { data: app, error: error2 } = await supabase.from("rbac_apps").select("id, name, requires_event, is_active").eq("name", appName2).eq("is_active", true).single();
+                if (error2) {
+                  if (error2.code === "406" || error2.code === "PGRST116" || error2.message?.includes("406")) {
+                    log.debug(`App resolution blocked by RLS for "${appName2}" - user may not be authenticated`);
+                    appId = void 0;
+                  } else {
+                    const { data: inactiveApp } = await supabase.from("rbac_apps").select("id, name, is_active").eq("name", appName2).single();
+                    if (inactiveApp) {
+                      log.error(`App "${appName2}" exists but is inactive (is_active: ${inactiveApp.is_active})`);
+                      appId = void 0;
+                    } else {
+                      log.error(`App "${appName2}" not found in rbac_apps table`, { error: error2 });
+                      appId = void 0;
+                    }
+                  }
+                } else if (app) {
+                  appId = app.id;
+                  appConfig = { requires_event: app.requires_event ?? false };
+                  appConfigCache.set(appName2, { appId, appConfig, timestamp: now });
+                }
+              }
+            }
+          } catch (error2) {
+            const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+            if (!errorMessage.includes("406") && !errorMessage.includes("PGRST116")) {
+              log.error("Unexpected error resolving app config:", error2);
+            } else {
+              log.debug("App resolution skipped - authentication required");
+            }
+          }
+        }
+        const initialScope = {
+          organisationId: appConfig?.requires_event ? void 0 : selectedOrganisationId || void 0,
+          eventId: selectedEventId || void 0,
+          appId
+        };
+        const validation = await ContextValidator.resolveRequiredContext(
+          initialScope,
+          appConfig,
+          appName2 || void 0,
+          supabase
+        );
+        if (!validation.isValid) {
+          if (appName2 === "PORTAL" || appName2 === "ADMIN") {
+            if (!cancelled) {
+              const optionalContextScope = {
+                organisationId: void 0,
+                eventId: void 0,
+                appId: appId || void 0
+                // appId might be undefined if query failed, that's OK
+              };
+              setResolvedScope(optionalContextScope);
+              setError(null);
+              setIsLoading(false);
+            }
+            return;
+          }
+          if (appConfig?.requires_event && selectedEventId) {
+            if (!cancelled) {
+              const eventScope = {
+                organisationId: void 0,
+                // Will be derived from event during permission check
+                eventId: selectedEventId,
+                appId: appId || void 0
+              };
+              setResolvedScope(eventScope);
+              setError(null);
+              setIsLoading(false);
+            }
+            return;
+          }
+          if (!cancelled) {
+            setResolvedScope(null);
+            setError(validation.error || new Error("Context validation failed"));
+            setIsLoading(false);
+          }
+          return;
+        }
+        if (!cancelled) {
+          setResolvedScope(validation.resolvedScope);
+          setError(null);
+          setIsLoading(false);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err);
+          setIsLoading(false);
+        }
+      }
+    };
+    resolveScope();
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedOrganisationId, selectedEventId, supabase]);
+  const allowsOptionalContexts = appName === "PORTAL" || appName === "ADMIN";
+  const hasValidScope = allowsOptionalContexts ? true : stableScope.appId || stableScope.organisationId;
+  const finalScope = useMemo(() => {
+    if (!hasValidScope) {
+      return allowsOptionalContexts ? {} : null;
+    }
+    const scope = {};
+    if (stableScope.organisationId) {
+      scope.organisationId = stableScope.organisationId;
+    }
+    if (stableScope.eventId) {
+      scope.eventId = stableScope.eventId;
+    }
+    if (stableScope.appId) {
+      scope.appId = stableScope.appId;
+    }
+    return scope;
+  }, [hasValidScope, allowsOptionalContexts, stableScope.organisationId, stableScope.eventId, stableScope.appId]);
+  return {
+    resolvedScope: finalScope,
+    isLoading,
+    error
+  };
 }
 
 // src/rbac/hooks/useRBAC.ts
-import { useState, useEffect, useCallback, useMemo } from "react";
+import { useState as useState2, useEffect as useEffect2, useCallback, useMemo as useMemo2 } from "react";
 function mapAccessLevelToEventRole(level) {
   switch (level) {
     case "viewer":
@@ -270,13 +573,13 @@ function useRBAC(pageId) {
     selectedEvent,
     eventLoading
   } = useUnifiedAuth();
-  const [globalRole, setGlobalRole] = useState(null);
-  const [organisationRole, setOrganisationRole] = useState(null);
-  const [eventAppRole, setEventAppRole] = useState(null);
-  const [permissionMap, setPermissionMap] = useState({});
-  const [currentScope, setCurrentScope] = useState(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState(null);
+  const [globalRole, setGlobalRole] = useState2(null);
+  const [organisationRole, setOrganisationRole] = useState2(null);
+  const [eventAppRole, setEventAppRole] = useState2(null);
+  const [permissionMap, setPermissionMap] = useState2({});
+  const [currentScope, setCurrentScope] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
   const resetState = useCallback(() => {
     setGlobalRole(null);
     setOrganisationRole(null);
@@ -316,7 +619,7 @@ function useRBAC(pageId) {
           if (!resolved) {
             if (appName === "PORTAL" || appName === "ADMIN") {
               try {
-                const { getAppConfigByName } = await import("./api-N774RPUA.js");
+                const { getAppConfigByName } = await import("./api-MVVQZLJI.js");
                 await getAppConfigByName(appName);
               } catch (err) {
               }
@@ -401,12 +704,12 @@ function useRBAC(pageId) {
     },
     [globalRole, organisationRole, permissionMap]
   );
-  const isSuperAdmin = useMemo(() => globalRole === "super_admin" || permissionMap["*"] === true, [globalRole, permissionMap]);
-  const isOrgAdmin = useMemo(() => organisationRole === "org_admin" || isSuperAdmin, [organisationRole, isSuperAdmin]);
-  const isEventAdmin = useMemo(() => eventAppRole === "event_admin" || isSuperAdmin, [eventAppRole, isSuperAdmin]);
-  const canManageOrganisation = useMemo(() => isSuperAdmin || organisationRole === "org_admin", [isSuperAdmin, organisationRole]);
-  const canManageEvent = useMemo(() => isSuperAdmin || eventAppRole === "event_admin", [isSuperAdmin, eventAppRole]);
-  useEffect(() => {
+  const isSuperAdmin = useMemo2(() => globalRole === "super_admin" || permissionMap["*"] === true, [globalRole, permissionMap]);
+  const isOrgAdmin = useMemo2(() => organisationRole === "org_admin" || isSuperAdmin, [organisationRole, isSuperAdmin]);
+  const isEventAdmin = useMemo2(() => eventAppRole === "event_admin" || isSuperAdmin, [eventAppRole, isSuperAdmin]);
+  const canManageOrganisation = useMemo2(() => isSuperAdmin || organisationRole === "org_admin", [isSuperAdmin, organisationRole]);
+  const canManageEvent = useMemo2(() => isSuperAdmin || eventAppRole === "event_admin", [isSuperAdmin, eventAppRole]);
+  useEffect2(() => {
     loadRBACContext();
   }, [loadRBACContext, appName, appConfig, eventLoading, selectedEvent?.event_id, user, session, selectedOrganisation?.id, orgContextReady, orgLoading]);
   return {
@@ -425,197 +728,176 @@ function useRBAC(pageId) {
   };
 }
 
-// src/rbac/hooks/usePermissions.ts
-import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useMemo as useMemo2, useRef } from "react";
-
-// src/rbac/utils/deep-equal.ts
-function scopeEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (a == null || b == null) {
-    return a === b;
+// src/rbac/hooks/permissions/useAccessLevel.ts
+import { useCallback as useCallback2, useEffect as useEffect3, useMemo as useMemo3, useState as useState3 } from "react";
+function useAccessLevel(userId, scope) {
+  const [accessLevel, setAccessLevel] = useState3("viewer");
+  const [isLoading, setIsLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  let appName;
+  try {
+    const { appName: contextAppName } = useAppConfig();
+    appName = contextAppName;
+  } catch {
   }
-  return a.organisationId === b.organisationId && a.eventId === b.eventId && a.appId === b.appId;
-}
-
-// src/rbac/hooks/usePermissions.ts
-function usePermissions(userId, organisationId, eventId, appId) {
-  const [permissions, setPermissions] = useState2({});
-  const [isLoading, setIsLoading] = useState2(true);
-  const [error, setError] = useState2(null);
-  const [fetchTrigger, setFetchTrigger] = useState2(0);
-  const isFetchingRef = useRef(false);
-  const logger2 = getRBACLogger();
-  const prevValuesRef = useRef({ userId, organisationId, eventId, appId });
-  const orgId = organisationId || "";
-  useEffect2(() => {
+  const fetchAccessLevel = useCallback2(async () => {
     if (!userId) {
+      setAccessLevel("viewer");
+      setIsLoading(false);
       return;
     }
-    if (!orgId || orgId === null || typeof orgId === "string" && orgId.trim() === "") {
-      const timeoutId = setTimeout(() => {
-        setError(new Error("Organisation context is required for permission checks"));
-        setIsLoading(false);
-      }, 3e3);
-      return () => clearTimeout(timeoutId);
-    }
-    if (error?.message === "Organisation context is required for permission checks") {
+    try {
+      setIsLoading(true);
       setError(null);
-    }
-  }, [userId, organisationId, error, orgId]);
-  useEffect2(() => {
-    const paramsChanged = prevValuesRef.current.userId !== userId || prevValuesRef.current.organisationId !== organisationId || prevValuesRef.current.eventId !== eventId || prevValuesRef.current.appId !== appId;
-    if (paramsChanged) {
-      if (prevValuesRef.current.appId !== appId) {
-      }
-      prevValuesRef.current = { userId, organisationId, eventId, appId };
-      setFetchTrigger((prev) => prev + 1);
-    }
-  }, [userId, organisationId, eventId, appId, logger2]);
-  useEffect2(() => {
-    const fetchPermissions = async () => {
-      if (isFetchingRef.current) {
-        return;
-      }
-      if (!userId) {
-        setPermissions({});
+      const { isSuperAdmin: checkSuperAdmin } = await import("./api-MVVQZLJI.js");
+      const isSuperAdminUser = await checkSuperAdmin(userId);
+      if (isSuperAdminUser) {
+        setAccessLevel("super");
         setIsLoading(false);
         return;
       }
-      if (!userId) {
-        setPermissions({});
+      if (appName !== "PORTAL" && appName !== "ADMIN" && !scope.organisationId && !scope.eventId) {
+        const orgError = new OrganisationContextRequiredError();
+        setError(orgError);
+        setAccessLevel("viewer");
         setIsLoading(false);
         return;
       }
-      if (!orgId || orgId === null || typeof orgId === "string" && orgId.trim() === "") {
-        setIsLoading(true);
-        setError(null);
-        return;
-      }
-      try {
-        isFetchingRef.current = true;
-        setIsLoading(true);
-        setError(null);
-        const scope = {
-          organisationId: orgId,
-          eventId,
-          appId
-        };
-        const permissionMap = await getPermissionMap({ userId, scope });
-        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) {
-        logger2.error("[usePermissions] Failed to fetch permissions:", err);
-        setError(err instanceof Error ? err : new Error("Failed to fetch permissions"));
-      } finally {
-        setIsLoading(false);
-        isFetchingRef.current = false;
-      }
-    };
-    fetchPermissions();
-  }, [fetchTrigger, userId, organisationId, eventId, appId]);
-  const hasPermission = useCallback2((permission) => {
-    if (permissions["*"]) {
-      return true;
-    }
-    return permissions[permission] === true;
-  }, [permissions]);
-  const hasAnyPermission = useCallback2((permissionList) => {
-    if (permissions["*"]) {
-      return true;
-    }
-    return permissionList.some((p) => permissions[p] === true);
-  }, [permissions]);
-  const hasAllPermissions = useCallback2((permissionList) => {
-    if (permissions["*"]) {
-      return true;
-    }
-    return permissionList.every((p) => permissions[p] === true);
-  }, [permissions]);
-  const refetch = useCallback2(async () => {
-    if (isFetchingRef.current) {
-      return;
+      const level = await getAccessLevel({ userId, scope }, null, appName);
+      setAccessLevel(level);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to fetch access level");
+      setError(error2);
+      setAccessLevel("viewer");
+    } finally {
+      setIsLoading(false);
     }
+  }, [userId, scope.organisationId, scope.eventId, scope.appId, appName]);
+  useEffect3(() => {
+    fetchAccessLevel();
+  }, [fetchAccessLevel]);
+  return useMemo3(() => ({
+    accessLevel,
+    isLoading,
+    error,
+    refetch: fetchAccessLevel
+  }), [accessLevel, isLoading, error, fetchAccessLevel]);
+}
+
+// src/rbac/hooks/permissions/useCachedPermissions.ts
+import { useCallback as useCallback3, useEffect as useEffect4, useMemo as useMemo4, useState as useState4 } from "react";
+function useCachedPermissions(userId, scope) {
+  const [permissions, setPermissions] = useState4({});
+  const [isLoading, setIsLoading] = useState4(true);
+  const [error, setError] = useState4(null);
+  const fetchCachedPermissions = useCallback3(async () => {
     if (!userId) {
       setPermissions({});
       setIsLoading(false);
       return;
     }
-    if (!orgId || orgId === null || typeof orgId === "string" && orgId.trim() === "") {
-      setIsLoading(true);
-      setError(null);
-      return;
-    }
     try {
-      isFetchingRef.current = true;
       setIsLoading(true);
       setError(null);
-      const scope = {
-        organisationId: orgId,
-        eventId,
-        appId
-      };
       const permissionMap = await getPermissionMap({ userId, scope });
       setPermissions(permissionMap);
     } catch (err) {
-      const logger3 = getRBACLogger();
-      logger3.error("Failed to refetch permissions:", err);
-      setError(err instanceof Error ? err : new Error("Failed to fetch permissions"));
+      setError(err instanceof Error ? err : new Error("Failed to fetch cached permissions"));
     } finally {
       setIsLoading(false);
-      isFetchingRef.current = false;
     }
-  }, [userId, organisationId, eventId, appId]);
-  return useMemo2(() => ({
+  }, [userId, scope.organisationId, scope.eventId, scope.appId]);
+  const invalidateCache = useCallback3(() => {
+    fetchCachedPermissions();
+  }, [fetchCachedPermissions]);
+  useEffect4(() => {
+    fetchCachedPermissions();
+  }, [fetchCachedPermissions]);
+  return useMemo4(() => ({
     permissions,
     isLoading,
     error,
-    hasPermission,
-    hasAnyPermission,
-    hasAllPermissions,
-    refetch
-  }), [permissions, isLoading, error, hasPermission, hasAnyPermission, hasAllPermissions, refetch]);
+    invalidateCache,
+    refetch: fetchCachedPermissions
+  }), [permissions, isLoading, error, invalidateCache, fetchCachedPermissions]);
 }
-function useCan(userId, scope, permission, pageId, useCache = true, appName) {
-  const [can, setCan] = useState2(false);
-  const [isLoading, setIsLoading] = useState2(true);
-  const [error, setError] = useState2(null);
-  const [isSuperAdmin, setIsSuperAdmin] = useState2(null);
+
+// src/rbac/hooks/permissions/useCan.ts
+import { useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo5, useRef as useRef2, useState as useState5 } from "react";
+
+// src/rbac/utils/deep-equal.ts
+function scopeEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return a === b;
+  }
+  return a.organisationId === b.organisationId && a.eventId === b.eventId && a.appId === b.appId;
+}
+
+// src/rbac/hooks/permissions/useCan.ts
+function useCan(userId, scope, permission, pageId, useCache = true, precomputedSuperAdmin = null, appName) {
+  const [can, setCan] = useState5(false);
+  const [isLoading, setIsLoading] = useState5(true);
+  const [error, setError] = useState5(null);
+  const [isSuperAdmin, setIsSuperAdmin] = useState5(precomputedSuperAdmin ?? null);
   const isValidScope = scope && typeof scope === "object";
   const organisationId = isValidScope ? scope.organisationId : void 0;
   const eventId = isValidScope ? scope.eventId : void 0;
   const appId = isValidScope ? scope.appId : void 0;
-  useEffect2(() => {
-    if (!userId) {
-      setIsSuperAdmin(false);
-      return;
-    }
-    let cancelled = false;
-    const checkSuperAdmin = async () => {
-      try {
-        const { isSuperAdmin: checkSuperAdmin2 } = await import("./api-N774RPUA.js");
-        const isSuper = await checkSuperAdmin2(userId);
-        if (!cancelled) {
-          setIsSuperAdmin(isSuper);
-        }
-      } catch (err) {
-        if (!cancelled) {
-          setIsSuperAdmin(false);
-        }
+  useEffect5(() => {
+    if (precomputedSuperAdmin === null) {
+      if (!userId) {
+        setIsSuperAdmin(false);
+        return;
       }
-    };
-    checkSuperAdmin();
-    return () => {
-      cancelled = true;
-    };
-  }, [userId]);
-  useEffect2(() => {
+      let cancelled = false;
+      const checkSuperAdmin = async () => {
+        const startTime = Date.now();
+        try {
+          const { isSuperAdmin: checkSuperAdmin2 } = await import("./api-MVVQZLJI.js");
+          const timeoutWarning = setTimeout(() => {
+            if (!cancelled) {
+              console.warn("[useCan] Super admin check taking longer than 5 seconds", {
+                userId,
+                elapsedMs: Date.now() - startTime
+              });
+            }
+          }, 5e3);
+          const isSuper = await checkSuperAdmin2(userId);
+          clearTimeout(timeoutWarning);
+          if (!cancelled) {
+            const elapsed = Date.now() - startTime;
+            if (elapsed > 1e3) {
+              console.warn("[useCan] Super admin check took longer than expected", {
+                userId,
+                elapsedMs: elapsed
+              });
+            }
+            setIsSuperAdmin(isSuper);
+          }
+        } catch (err) {
+          if (!cancelled) {
+            const elapsed = Date.now() - startTime;
+            console.error("[useCan] Error checking super admin", {
+              userId,
+              error: err,
+              elapsedMs: elapsed
+            });
+            setIsSuperAdmin(false);
+          }
+        }
+      };
+      checkSuperAdmin();
+      return () => {
+        cancelled = true;
+      };
+    } else {
+      setIsSuperAdmin(precomputedSuperAdmin);
+    }
+  }, [userId, precomputedSuperAdmin]);
+  useEffect5(() => {
     const isPagePermission = permission.includes(":page.") || !!pageId;
     const requiresOrgId = !isPagePermission;
     if (isSuperAdmin === true) {
@@ -633,12 +915,12 @@ function useCan(userId, scope, permission, pageId, useCache = true, appName) {
       setError(null);
     }
   }, [isValidScope, organisationId, error, permission, pageId, isSuperAdmin]);
-  const lastUserIdRef = useRef(null);
-  const lastScopeRef = useRef(null);
-  const lastPermissionRef = useRef(null);
-  const lastPageIdRef = useRef(null);
-  const lastUseCacheRef = useRef(null);
-  const stableScope = useMemo2(() => {
+  const lastUserIdRef = useRef2(null);
+  const lastScopeRef = useRef2(null);
+  const lastPermissionRef = useRef2(null);
+  const lastPageIdRef = useRef2(null);
+  const lastUseCacheRef = useRef2(null);
+  const stableScope = useMemo5(() => {
     if (!isValidScope) {
       return null;
     }
@@ -648,8 +930,8 @@ function useCan(userId, scope, permission, pageId, useCache = true, appName) {
       appId
     };
   }, [isValidScope, organisationId, eventId, appId]);
-  const prevScopeRef = useRef(null);
-  useEffect2(() => {
+  const prevScopeRef = useRef2(null);
+  useEffect5(() => {
     const scopeChanged = !scopeEqual(prevScopeRef.current, stableScope);
     if (lastUserIdRef.current !== userId || scopeChanged || lastPermissionRef.current !== permission || lastPageIdRef.current !== pageId || lastUseCacheRef.current !== useCache) {
       lastUserIdRef.current = userId;
@@ -660,7 +942,19 @@ function useCan(userId, scope, permission, pageId, useCache = true, appName) {
       const checkPermission = async () => {
         if (!userId) {
           setCan(false);
-          setIsLoading(false);
+          setIsLoading(false);
+          return;
+        }
+        if (isSuperAdmin === true) {
+          setCan(true);
+          setIsLoading(false);
+          setError(null);
+          return;
+        }
+        if (isSuperAdmin === null) {
+          setIsLoading(true);
+          setCan(false);
+          setError(null);
           return;
         }
         if (!isValidScope) {
@@ -674,13 +968,10 @@ function useCan(userId, scope, permission, pageId, useCache = true, appName) {
         const isPageName = pageId && typeof pageId === "string" && !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(pageId);
         const needsAppIdForPageName = isPagePermission && isPageName;
         if (requiresOrgId && (!organisationId || organisationId === null || typeof organisationId === "string" && organisationId.trim() === "")) {
-          if (isSuperAdmin === true) {
-          } else {
-            setIsLoading(true);
-            setCan(false);
-            setError(null);
-            return;
-          }
+          setIsLoading(true);
+          setCan(false);
+          setError(null);
+          return;
         }
         if (needsAppIdForPageName && (!appId || appId === null || typeof appId === "string" && appId.trim() === "")) {
           setIsLoading(true);
@@ -696,11 +987,12 @@ function useCan(userId, scope, permission, pageId, useCache = true, appName) {
             ...eventId ? { eventId } : {},
             ...appId ? { appId } : {}
           };
-          const result = useCache ? await isPermittedCached({ userId, scope: validScope, permission, pageId }, void 0, appName) : await isPermitted({ userId, scope: validScope, permission, pageId }, void 0, appName);
+          const result = useCache ? await isPermittedCached({ userId, scope: validScope, permission, pageId }, void 0, appName) : await isPermitted({ userId, scope: validScope, permission, pageId }, void 0, appName, isSuperAdmin === false ? false : null);
           setCan(result);
         } catch (err) {
           const logger2 = getRBACLogger();
           logger2.error("Permission check error:", { permission, error: err });
+          console.error("[useCan] Permission check error", { userId, permission, error: err });
           setError(err instanceof Error ? err : new Error("Failed to check permission"));
           setCan(false);
         } finally {
@@ -710,7 +1002,7 @@ function useCan(userId, scope, permission, pageId, useCache = true, appName) {
       checkPermission();
     }
   }, [userId, stableScope, permission, pageId, useCache, appName, isSuperAdmin]);
-  const refetch = useCallback2(async () => {
+  const refetch = useCallback4(async () => {
     if (!userId) {
       setCan(false);
       setIsLoading(false);
@@ -738,7 +1030,7 @@ function useCan(userId, scope, permission, pageId, useCache = true, appName) {
         ...eventId ? { eventId } : {},
         ...appId ? { appId } : {}
       };
-      const result = useCache ? await isPermittedCached({ userId, scope: validScope, permission, pageId }, void 0, appName) : await isPermitted({ userId, scope: validScope, permission, pageId }, void 0, appName);
+      const result = useCache ? await isPermittedCached({ userId, scope: validScope, permission, pageId }, void 0, appName) : await isPermitted({ userId, scope: validScope, permission, pageId }, void 0, appName, null);
       setCan(result);
     } catch (err) {
       setError(err instanceof Error ? err : new Error("Failed to check permission"));
@@ -747,107 +1039,63 @@ function useCan(userId, scope, permission, pageId, useCache = true, appName) {
       setIsLoading(false);
     }
   }, [userId, isValidScope, organisationId, eventId, appId, permission, pageId, useCache, appName]);
-  return useMemo2(() => ({
+  return useMemo5(() => ({
     can,
     isLoading,
     error,
     refetch
   }), [can, isLoading, error, refetch]);
 }
-function useAccessLevel(userId, scope) {
-  const [accessLevel, setAccessLevel] = useState2("viewer");
-  const [isLoading, setIsLoading] = useState2(true);
-  const [error, setError] = useState2(null);
-  let appName;
-  try {
-    const { appName: contextAppName } = useAppConfig();
-    appName = contextAppName;
-  } catch {
-  }
-  const fetchAccessLevel = useCallback2(async () => {
-    if (!userId) {
-      setAccessLevel("viewer");
-      setIsLoading(false);
-      return;
-    }
-    try {
-      setIsLoading(true);
-      setError(null);
-      const { isSuperAdmin: checkSuperAdmin } = await import("./api-N774RPUA.js");
-      const isSuperAdminUser = await checkSuperAdmin(userId);
-      if (isSuperAdminUser) {
-        setAccessLevel("super");
-        setIsLoading(false);
-        return;
-      }
-      if (appName !== "PORTAL" && appName !== "ADMIN" && !scope.organisationId && !scope.eventId) {
-        const orgError = new OrganisationContextRequiredError();
-        setError(orgError);
-        setAccessLevel("viewer");
-        setIsLoading(false);
-        return;
-      }
-      const level = await getAccessLevel({ userId, scope }, null, appName);
-      setAccessLevel(level);
-    } catch (err) {
-      const error2 = err instanceof Error ? err : new Error("Failed to fetch access level");
-      setError(error2);
-      setAccessLevel("viewer");
-    } finally {
-      setIsLoading(false);
-    }
-  }, [userId, scope.organisationId, scope.eventId, scope.appId, appName]);
-  useEffect2(() => {
-    fetchAccessLevel();
-  }, [fetchAccessLevel]);
-  return useMemo2(() => ({
-    accessLevel,
-    isLoading,
-    error,
-    refetch: fetchAccessLevel
-  }), [accessLevel, isLoading, error, fetchAccessLevel]);
-}
-function useMultiplePermissions(userId, scope, permissions, useCache = true) {
-  const [results, setResults] = useState2({});
-  const [isLoading, setIsLoading] = useState2(true);
-  const [error, setError] = useState2(null);
-  const checkPermissions = useCallback2(async () => {
+
+// src/rbac/hooks/permissions/useHasAllPermissions.ts
+import { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo6, useState as useState6 } from "react";
+function useHasAllPermissions(userId, scope, permissions, useCache = true) {
+  const [hasAll, setHasAll] = useState6(false);
+  const [isLoading, setIsLoading] = useState6(true);
+  const [error, setError] = useState6(null);
+  const checkAllPermissions = useCallback5(async () => {
     if (!userId || permissions.length === 0) {
-      setResults({});
+      setHasAll(false);
       setIsLoading(false);
       return;
     }
     try {
       setIsLoading(true);
       setError(null);
-      const permissionResults = {};
+      let hasAllPermissions = true;
       for (const permission of permissions) {
-        const result = useCache ? await isPermittedCached({ userId, scope, permission }) : await isPermitted({ userId, scope, permission });
-        permissionResults[permission] = result;
+        const result = useCache ? await isPermittedCached({ userId, scope, permission }) : await isPermitted({ userId, scope, permission }, null, void 0, null);
+        if (!result) {
+          hasAllPermissions = false;
+          break;
+        }
       }
-      setResults(permissionResults);
+      setHasAll(hasAllPermissions);
     } catch (err) {
       setError(err instanceof Error ? err : new Error("Failed to check permissions"));
-      setResults({});
+      setHasAll(false);
     } finally {
       setIsLoading(false);
     }
   }, [userId, scope.organisationId, scope.eventId, scope.appId, permissions, useCache]);
-  useEffect2(() => {
-    checkPermissions();
-  }, [checkPermissions]);
-  return useMemo2(() => ({
-    results,
+  useEffect6(() => {
+    checkAllPermissions();
+  }, [checkAllPermissions]);
+  return useMemo6(() => ({
+    hasAll,
     isLoading,
     error,
-    refetch: checkPermissions
-  }), [results, isLoading, error, checkPermissions]);
+    refetch: checkAllPermissions
+  }), [hasAll, isLoading, error, checkAllPermissions]);
 }
+
+// src/rbac/hooks/permissions/useHasAnyPermission.ts
+import { useCallback as useCallback6, useEffect as useEffect7, useMemo as useMemo7, useState as useState7 } from "react";
 function useHasAnyPermission(userId, scope, permissions, useCache = true) {
-  const [hasAny, setHasAny] = useState2(false);
-  const [isLoading, setIsLoading] = useState2(true);
-  const [error, setError] = useState2(null);
-  const checkAnyPermission = useCallback2(async () => {
+  const [hasAny, setHasAny] = useState7(false);
+  const [isLoading, setIsLoading] = useState7(true);
+  const [error, setError] = useState7(null);
+  const checkAnyPermission = useCallback6(async () => {
     if (!userId || permissions.length === 0) {
       setHasAny(false);
       setIsLoading(false);
@@ -858,7 +1106,7 @@ function useHasAnyPermission(userId, scope, permissions, useCache = true) {
       setError(null);
       let hasAnyPermission = false;
       for (const permission of permissions) {
-        const result = useCache ? await isPermittedCached({ userId, scope, permission }) : await isPermitted({ userId, scope, permission });
+        const result = useCache ? await isPermittedCached({ userId, scope, permission }) : await isPermitted({ userId, scope, permission }, null, void 0, null);
         if (result) {
           hasAnyPermission = true;
           break;
@@ -872,93 +1120,203 @@ function useHasAnyPermission(userId, scope, permissions, useCache = true) {
       setIsLoading(false);
     }
   }, [userId, scope.organisationId, scope.eventId, scope.appId, permissions, useCache]);
-  useEffect2(() => {
+  useEffect7(() => {
     checkAnyPermission();
   }, [checkAnyPermission]);
-  return useMemo2(() => ({
+  return useMemo7(() => ({
     hasAny,
     isLoading,
     error,
     refetch: checkAnyPermission
   }), [hasAny, isLoading, error, checkAnyPermission]);
 }
-function useHasAllPermissions(userId, scope, permissions, useCache = true) {
-  const [hasAll, setHasAll] = useState2(false);
-  const [isLoading, setIsLoading] = useState2(true);
-  const [error, setError] = useState2(null);
-  const checkAllPermissions = useCallback2(async () => {
+
+// src/rbac/hooks/permissions/useMultiplePermissions.ts
+import { useCallback as useCallback7, useEffect as useEffect8, useMemo as useMemo8, useState as useState8 } from "react";
+function useMultiplePermissions(userId, scope, permissions, useCache = true) {
+  const [results, setResults] = useState8({});
+  const [isLoading, setIsLoading] = useState8(true);
+  const [error, setError] = useState8(null);
+  const checkPermissions = useCallback7(async () => {
     if (!userId || permissions.length === 0) {
-      setHasAll(false);
+      setResults({});
       setIsLoading(false);
       return;
     }
     try {
       setIsLoading(true);
       setError(null);
-      let hasAllPermissions = true;
+      const permissionResults = {};
       for (const permission of permissions) {
-        const result = useCache ? await isPermittedCached({ userId, scope, permission }) : await isPermitted({ userId, scope, permission });
-        if (!result) {
-          hasAllPermissions = false;
-          break;
-        }
+        const result = useCache ? await isPermittedCached({ userId, scope, permission }) : await isPermitted({ userId, scope, permission }, null, void 0, null);
+        permissionResults[permission] = result;
       }
-      setHasAll(hasAllPermissions);
+      setResults(permissionResults);
     } catch (err) {
       setError(err instanceof Error ? err : new Error("Failed to check permissions"));
-      setHasAll(false);
+      setResults({});
     } finally {
       setIsLoading(false);
     }
   }, [userId, scope.organisationId, scope.eventId, scope.appId, permissions, useCache]);
-  useEffect2(() => {
-    checkAllPermissions();
-  }, [checkAllPermissions]);
-  return useMemo2(() => ({
-    hasAll,
+  useEffect8(() => {
+    checkPermissions();
+  }, [checkPermissions]);
+  return useMemo8(() => ({
+    results,
     isLoading,
     error,
-    refetch: checkAllPermissions
-  }), [hasAll, isLoading, error, checkAllPermissions]);
+    refetch: checkPermissions
+  }), [results, isLoading, error, checkPermissions]);
 }
-function useCachedPermissions(userId, scope) {
-  const [permissions, setPermissions] = useState2({});
-  const [isLoading, setIsLoading] = useState2(true);
-  const [error, setError] = useState2(null);
-  const fetchCachedPermissions = useCallback2(async () => {
+
+// src/rbac/hooks/permissions/usePermissions.ts
+import { useCallback as useCallback8, useEffect as useEffect9, useMemo as useMemo9, useRef as useRef3, useState as useState9 } from "react";
+function usePermissions(userId, organisationId, eventId, appId) {
+  const [permissions, setPermissions] = useState9({});
+  const [isLoading, setIsLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const [fetchTrigger, setFetchTrigger] = useState9(0);
+  const isFetchingRef = useRef3(false);
+  const logger2 = getRBACLogger();
+  const prevValuesRef = useRef3({ userId, organisationId, eventId, appId });
+  const orgId = organisationId || "";
+  useEffect9(() => {
+    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"));
+        setIsLoading(false);
+      }, 3e3);
+      return () => clearTimeout(timeoutId);
+    }
+    if (error?.message === "Organisation context is required for permission checks") {
+      setError(null);
+    }
+  }, [userId, organisationId, error, orgId]);
+  useEffect9(() => {
+    const paramsChanged = prevValuesRef.current.userId !== userId || prevValuesRef.current.organisationId !== organisationId || prevValuesRef.current.eventId !== eventId || prevValuesRef.current.appId !== appId;
+    if (paramsChanged) {
+      if (prevValuesRef.current.appId !== appId) {
+      }
+      prevValuesRef.current = { userId, organisationId, eventId, appId };
+      setFetchTrigger((prev) => prev + 1);
+    }
+  }, [userId, organisationId, eventId, appId, logger2]);
+  useEffect9(() => {
+    const fetchPermissions = async () => {
+      if (isFetchingRef.current) {
+        return;
+      }
+      if (!userId) {
+        setPermissions({});
+        setIsLoading(false);
+        return;
+      }
+      if (!userId) {
+        setPermissions({});
+        setIsLoading(false);
+        return;
+      }
+      if (!orgId || orgId === null || typeof orgId === "string" && orgId.trim() === "") {
+        setIsLoading(true);
+        setError(null);
+        return;
+      }
+      try {
+        isFetchingRef.current = true;
+        setIsLoading(true);
+        setError(null);
+        const scope = {
+          organisationId: orgId,
+          eventId,
+          appId
+        };
+        const permissionMap = await getPermissionMap({ userId, scope });
+        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) {
+        logger2.error("[usePermissions] Failed to fetch permissions:", err);
+        setError(err instanceof Error ? err : new Error("Failed to fetch permissions"));
+      } finally {
+        setIsLoading(false);
+        isFetchingRef.current = false;
+      }
+    };
+    fetchPermissions();
+  }, [fetchTrigger, userId, organisationId, eventId, appId]);
+  const hasPermission = useCallback8((permission) => {
+    if (permissions["*"]) {
+      return true;
+    }
+    return permissions[permission] === true;
+  }, [permissions]);
+  const hasAnyPermission = useCallback8((permissionList) => {
+    if (permissions["*"]) {
+      return true;
+    }
+    return permissionList.some((p) => permissions[p] === true);
+  }, [permissions]);
+  const hasAllPermissions = useCallback8((permissionList) => {
+    if (permissions["*"]) {
+      return true;
+    }
+    return permissionList.every((p) => permissions[p] === true);
+  }, [permissions]);
+  const refetch = useCallback8(async () => {
+    if (isFetchingRef.current) {
+      return;
+    }
     if (!userId) {
       setPermissions({});
       setIsLoading(false);
       return;
     }
+    if (!orgId || orgId === null || typeof orgId === "string" && orgId.trim() === "") {
+      setIsLoading(true);
+      setError(null);
+      return;
+    }
     try {
+      isFetchingRef.current = true;
       setIsLoading(true);
       setError(null);
+      const scope = {
+        organisationId: orgId,
+        eventId,
+        appId
+      };
       const permissionMap = await getPermissionMap({ userId, scope });
       setPermissions(permissionMap);
     } catch (err) {
-      setError(err instanceof Error ? err : new Error("Failed to fetch cached permissions"));
+      const logger3 = getRBACLogger();
+      logger3.error("Failed to refetch permissions:", err);
+      setError(err instanceof Error ? err : new Error("Failed to fetch permissions"));
     } finally {
       setIsLoading(false);
+      isFetchingRef.current = false;
     }
-  }, [userId, scope.organisationId, scope.eventId, scope.appId]);
-  const invalidateCache = useCallback2(() => {
-    fetchCachedPermissions();
-  }, [fetchCachedPermissions]);
-  useEffect2(() => {
-    fetchCachedPermissions();
-  }, [fetchCachedPermissions]);
-  return useMemo2(() => ({
+  }, [userId, organisationId, eventId, appId]);
+  return useMemo9(() => ({
     permissions,
     isLoading,
     error,
-    invalidateCache,
-    refetch: fetchCachedPermissions
-  }), [permissions, isLoading, error, invalidateCache, fetchCachedPermissions]);
+    hasPermission,
+    hasAnyPermission,
+    hasAllPermissions,
+    refetch
+  }), [permissions, isLoading, error, hasPermission, hasAnyPermission, hasAllPermissions, refetch]);
 }
 
 // src/rbac/hooks/useResourcePermissions.ts
-import { useMemo as useMemo3 } from "react";
+import { useMemo as useMemo10 } from "react";
 function useResourcePermissions(resource, options = {}) {
   const { enableRead = false, requireScope = true } = options;
   const { user, supabase } = useUnifiedAuth();
@@ -986,8 +1344,12 @@ function useResourcePermissions(resource, options = {}) {
     `create:${resource}`,
     pageId,
     // Pass resource name as pageId when appId is available to enable page permission checks
-    true
+    true,
     // useCache
+    null,
+    // precomputedSuperAdmin - not checked yet
+    void 0
+    // appName
   );
   const { can: canUpdateResult, isLoading: updateLoading, error: updateError } = useCan(
     user?.id || "",
@@ -995,8 +1357,12 @@ function useResourcePermissions(resource, options = {}) {
     `update:${resource}`,
     pageId,
     // Pass resource name as pageId when appId is available to enable page permission checks
-    true
+    true,
     // useCache
+    null,
+    // precomputedSuperAdmin - not checked yet
+    void 0
+    // appName
   );
   const { can: canDeleteResult, isLoading: deleteLoading, error: deleteError } = useCan(
     user?.id || "",
@@ -1004,8 +1370,12 @@ function useResourcePermissions(resource, options = {}) {
     `delete:${resource}`,
     pageId,
     // Pass resource name as pageId when appId is available to enable page permission checks
-    true
+    true,
     // useCache
+    null,
+    // precomputedSuperAdmin - not checked yet
+    void 0
+    // appName
   );
   const { can: canReadResult, isLoading: readLoading, error: readError } = useCan(
     user?.id || "",
@@ -1013,13 +1383,17 @@ function useResourcePermissions(resource, options = {}) {
     `read:${resource}`,
     pageId,
     // Pass resource name as pageId when appId is available to enable page permission checks
-    true
+    true,
     // useCache
+    null,
+    // precomputedSuperAdmin - not checked yet
+    void 0
+    // appName
   );
-  const isLoading = useMemo3(() => {
+  const isLoading = useMemo10(() => {
     return scopeLoading || createLoading || updateLoading || deleteLoading || enableRead && readLoading;
   }, [scopeLoading, createLoading, updateLoading, deleteLoading, readLoading, enableRead]);
-  const error = useMemo3(() => {
+  const error = useMemo10(() => {
     if (scopeError) return scopeError;
     if (createError) return createError;
     if (updateError) return updateError;
@@ -1027,7 +1401,7 @@ function useResourcePermissions(resource, options = {}) {
     if (enableRead && readError) return readError;
     return null;
   }, [scopeError, createError, updateError, deleteError, readError, enableRead]);
-  return useMemo3(() => ({
+  return useMemo10(() => ({
     canCreate: (res) => {
       if (res !== resource) {
         return false;
@@ -1072,15 +1446,15 @@ function useResourcePermissions(resource, options = {}) {
 }
 
 // src/rbac/hooks/useRoleManagement.ts
-import { useState as useState3, useCallback as useCallback3 } from "react";
+import { useState as useState10, useCallback as useCallback9 } from "react";
 function useRoleManagement() {
   const { user, supabase } = useUnifiedAuth();
-  const [isLoading, setIsLoading] = useState3(false);
-  const [error, setError] = useState3(null);
+  const [isLoading, setIsLoading] = useState10(false);
+  const [error, setError] = useState10(null);
   if (!supabase) {
     throw new Error("useRoleManagement requires a Supabase client. Ensure UnifiedAuthProvider is configured.");
   }
-  const revokeEventAppRole = useCallback3(async (params) => {
+  const revokeEventAppRole = useCallback9(async (params) => {
     setIsLoading(true);
     setError(null);
     try {
@@ -1111,7 +1485,7 @@ function useRoleManagement() {
       setIsLoading(false);
     }
   }, [user?.id]);
-  const grantEventAppRole = useCallback3(async (params) => {
+  const grantEventAppRole = useCallback9(async (params) => {
     setIsLoading(true);
     setError(null);
     try {
@@ -1150,7 +1524,7 @@ function useRoleManagement() {
       setIsLoading(false);
     }
   }, [user?.id]);
-  const revokeRoleById = useCallback3(async (roleId) => {
+  const revokeRoleById = useCallback9(async (roleId) => {
     setIsLoading(true);
     setError(null);
     try {
@@ -1186,7 +1560,7 @@ function useRoleManagement() {
       setIsLoading(false);
     }
   }, [user?.id, supabase]);
-  const grantGlobalRole = useCallback3(async (params) => {
+  const grantGlobalRole = useCallback9(async (params) => {
     setIsLoading(true);
     setError(null);
     try {
@@ -1225,7 +1599,7 @@ function useRoleManagement() {
       setIsLoading(false);
     }
   }, [user?.id, supabase]);
-  const revokeGlobalRole = useCallback3(async (params) => {
+  const revokeGlobalRole = useCallback9(async (params) => {
     setIsLoading(true);
     setError(null);
     try {
@@ -1257,7 +1631,7 @@ function useRoleManagement() {
       setIsLoading(false);
     }
   }, [user?.id, supabase]);
-  const grantOrganisationRole = useCallback3(async (params) => {
+  const grantOrganisationRole = useCallback9(async (params) => {
     setIsLoading(true);
     setError(null);
     try {
@@ -1296,7 +1670,7 @@ function useRoleManagement() {
       setIsLoading(false);
     }
   }, [user?.id, supabase]);
-  const revokeOrganisationRole = useCallback3(async (params) => {
+  const revokeOrganisationRole = useCallback9(async (params) => {
     setIsLoading(true);
     setError(null);
     try {
@@ -1346,11 +1720,11 @@ function useRoleManagement() {
 }
 
 // src/rbac/hooks/useSecureSupabase.ts
-import { useMemo as useMemo4, useRef as useRef2 } from "react";
+import { useMemo as useMemo11, useRef as useRef4 } from "react";
 var secureClientCache = /* @__PURE__ */ new Map();
 var MAX_CACHE_SIZE = 5;
 function getCacheKey(organisationId, eventId, appId, isSuperAdmin) {
-  return `${organisationId}-${eventId || "no-event"}-${appId || "no-app"}-${isSuperAdmin ? "super" : "regular"}`;
+  return `${organisationId || "no-org"}-${eventId || "no-event"}-${appId || "no-app"}-${isSuperAdmin ? "super" : "regular"}`;
 }
 function getSupabaseConfig() {
   const getEnvVar = (key) => {
@@ -1382,19 +1756,20 @@ function useSecureSupabase(baseClient) {
     selectedOrganisationId: selectedOrganisation?.id || null,
     selectedEventId: selectedEvent?.event_id || null
   });
-  const prevContextRef = useRef2({
+  const prevContextRef = useRef4({
     organisationId: void 0,
     eventId: void 0,
     appId: void 0
   });
-  return useMemo4(() => {
+  return useMemo11(() => {
     if (eventLoading) {
       return baseClient || authSupabase || null;
     }
     const organisationId = resolvedScope?.organisationId;
     const eventId = resolvedScope?.eventId || selectedEvent?.event_id;
     const appId = resolvedScope?.appId;
-    if (organisationId && user?.id) {
+    const canCreateSecureClient = user?.id && (isSuperAdmin || organisationId);
+    if (canCreateSecureClient) {
       prevContextRef.current = { organisationId, eventId, appId };
       const cacheKey = getCacheKey(organisationId, eventId, appId, isSuperAdmin);
       const cachedClient = secureClientCache.get(cacheKey);
@@ -1409,11 +1784,19 @@ function useSecureSupabase(baseClient) {
         return baseClient || authSupabase || null;
       }
       try {
-        const secureClient = createSecureClient(
+        const effectiveOrganisationId = isSuperAdmin ? organisationId || null : organisationId;
+        const baseForSecureClient = baseClient || authSupabase || null;
+        const secureClient = baseForSecureClient ? fromSupabaseClient(
+          baseForSecureClient,
+          effectiveOrganisationId ?? null,
+          eventId,
+          appId,
+          isSuperAdmin
+        ) : createSecureClient(
           config.url,
           config.key,
-          organisationId,
-          // organisationId is string, UUID is string alias
+          effectiveOrganisationId,
+          // organisationId is string | null, UUID is string alias
           eventId,
           appId,
           // appId is string | undefined, UUID is string alias
@@ -1451,17 +1834,18 @@ export {
   SecureSupabaseClient,
   createSecureClient,
   fromSupabaseClient,
+  useResolvedScope,
   useRBAC,
+  useAccessLevel,
+  useCachedPermissions,
   scopeEqual,
-  usePermissions,
   useCan,
-  useAccessLevel,
-  useMultiplePermissions,
-  useHasAnyPermission,
   useHasAllPermissions,
-  useCachedPermissions,
+  useHasAnyPermission,
+  useMultiplePermissions,
+  usePermissions,
   useResourcePermissions,
   useRoleManagement,
   useSecureSupabase
 };
-//# sourceMappingURL=chunk-XNXXZ43G.js.map
+//# sourceMappingURL=chunk-XWQCNGTQ.js.map