@jmruthers/pace-core 0.5.188 → 0.5.190

package/dist/{chunk-UNOTYLQF.js → chunk-NIU6J6OX.js}

@@ -1,9 +1,6 @@
 import {
   useEvents
-} from "./chunk-E7UAOUMY.js";
-import {
-  useUnifiedAuth
-} from "./chunk-VGZZXKBR.js";
+} from "./chunk-Y4BUBBHD.js";
 import {
   assertAppId
 } from "./chunk-QXHPKYJV.js";
@@ -11,9 +8,8 @@ import {
   createAddressFromPlaceResult,
   fetchPlaceAutocomplete,
   fetchPlaceDetails,
-  getAddressByPlaceId,
-  performanceBudgetMonitor
-} from "./chunk-YHCN776L.js";
+  getAddressByPlaceId
+} from "./chunk-DZWK57KZ.js";
 import {
   setOrganisationContext
 } from "./chunk-VBXEHIUJ.js";
@@ -64,6 +60,20 @@ function runCacheCleanup() {
 if (typeof window !== "undefined" && !cleanupTimer) {
   cleanupTimer = setInterval(runCacheCleanup, CLEANUP_INTERVAL_MS);
   log.debug("Query cache cleanup initialized.");
+  window.addEventListener("beforeunload", () => {
+    if (cleanupTimer) {
+      clearInterval(cleanupTimer);
+      cleanupTimer = null;
+      log.debug("Query cache cleanup timer cleared on page unload.");
+    }
+  });
+}
+function cleanupQueryCache() {
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+    log.debug("Query cache cleanup timer cleared.");
+  }
 }
 function useQueryCache(supabase) {
   const getCachedQuery = useCallback(async (table, filterKey, filterValue, fetchFn, options = {}) => {
@@ -371,337 +381,6 @@ function useAddressAutocomplete(apiKey, inputValue, options = {}) {
   };
 }
 
-// src/hooks/useEventTheme.ts
-import { useEffect as useEffect4 } from "react";
-import { useLocation } from "react-router-dom";
-var log2 = createLogger("useEventTheme");
-function useEventTheme(event) {
-  const location = useLocation();
-  let selectedEvent;
-  try {
-    if (event === void 0) {
-      const eventsContext = useEvents();
-      selectedEvent = eventsContext.selectedEvent;
-    } else {
-      selectedEvent = event;
-    }
-  } catch (error) {
-    if (event !== void 0) {
-      selectedEvent = event;
-    } else {
-      selectedEvent = null;
-    }
-  }
-  useEffect4(() => {
-    const isOnLoginRoute = location.pathname === "/login" || location.pathname.startsWith("/login");
-    if (isOnLoginRoute) {
-      clearPalette();
-      return;
-    }
-    if (!selectedEvent) {
-      clearPalette();
-      return;
-    }
-    const eventColours = selectedEvent.event_colours;
-    const normalized = parseAndNormalizeEventColours(eventColours);
-    if (!normalized) {
-      clearPalette();
-      return;
-    }
-    try {
-      applyPalette(normalized);
-    } catch (error) {
-      log2.error("Failed to apply event palette:", error);
-    }
-    return () => {
-    };
-  }, [selectedEvent, location.pathname]);
-}
-
-// src/hooks/usePreventTabReload.ts
-import { useEffect as useEffect5, useRef as useRef3 } from "react";
-function usePreventTabReload(options = {}) {
-  const { enabled = true, gracePeriodMs = 2e3 } = options;
-  const isRestoringFromCacheRef = useRef3(false);
-  const gracePeriodTimeoutRef = useRef3(null);
-  useEffect5(() => {
-    if (!enabled || typeof window === "undefined") return;
-    const handlePageShow = (event) => {
-      if (event.persisted) {
-        isRestoringFromCacheRef.current = true;
-        if (gracePeriodTimeoutRef.current) {
-          clearTimeout(gracePeriodTimeoutRef.current);
-        }
-        gracePeriodTimeoutRef.current = setTimeout(() => {
-          isRestoringFromCacheRef.current = false;
-        }, gracePeriodMs);
-      }
-    };
-    const handleVisibilityChange = () => {
-      if (!document.hidden) {
-        isRestoringFromCacheRef.current = true;
-        if (gracePeriodTimeoutRef.current) {
-          clearTimeout(gracePeriodTimeoutRef.current);
-        }
-        gracePeriodTimeoutRef.current = setTimeout(() => {
-          isRestoringFromCacheRef.current = false;
-        }, gracePeriodMs);
-      }
-    };
-    window.addEventListener("pageshow", handlePageShow);
-    document.addEventListener("visibilitychange", handleVisibilityChange);
-    return () => {
-      window.removeEventListener("pageshow", handlePageShow);
-      document.removeEventListener("visibilitychange", handleVisibilityChange);
-      if (gracePeriodTimeoutRef.current) {
-        clearTimeout(gracePeriodTimeoutRef.current);
-      }
-    };
-  }, [enabled, gracePeriodMs]);
-}
-
-// src/components/ErrorBoundary/ErrorBoundary.tsx
-import { Component } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-var ErrorBoundary = class extends Component {
-  constructor(props) {
-    super(props);
-    this.retryTimeoutId = null;
-    this.reportError = (errorId, componentName) => {
-      if (import.meta.env.MODE === "production") {
-        logger.warn("ErrorBoundary", "Error reporting would be triggered in production:", { errorId, componentName });
-      }
-    };
-    this.handleRetry = () => {
-      const { maxRetries = 3 } = this.props;
-      const { retryCount } = this.state;
-      if (retryCount < maxRetries) {
-        logger.debug("ErrorBoundary", `Retrying component render (attempt ${retryCount + 1}/${maxRetries})`);
-        this.setState((prevState) => ({
-          hasError: false,
-          error: void 0,
-          errorInfo: void 0,
-          errorId: void 0,
-          retryCount: prevState.retryCount + 1
-        }));
-      }
-    };
-    this.state = {
-      hasError: false,
-      retryCount: 0
-    };
-  }
-  static getDerivedStateFromError(error) {
-    const errorId = `error_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    return {
-      hasError: true,
-      error,
-      errorId
-    };
-  }
-  componentDidCatch(error, errorInfo) {
-    const { componentName = "Unknown Component", onError, enableReporting = true } = this.props;
-    const errorId = this.state.errorId;
-    this.setState({ errorInfo });
-    logger.error("ErrorBoundary", `[${componentName}] Caught error ${errorId}:`, error, errorInfo);
-    performanceBudgetMonitor.measure("ERROR_BOUNDARY_TRIGGER", 1, {
-      componentName,
-      errorId,
-      errorMessage: error.message,
-      stack: error.stack?.substring(0, 200)
-      // Truncated stack trace
-    });
-    if (enableReporting) {
-      this.reportError(errorId, componentName);
-    }
-    if (onError) {
-      onError(error, errorInfo, errorId);
-    }
-  }
-  componentWillUnmount() {
-    if (this.retryTimeoutId) {
-      clearTimeout(this.retryTimeoutId);
-    }
-  }
-  render() {
-    if (this.state.hasError) {
-      const {
-        componentName = "Component",
-        fallback,
-        enableRetry = true,
-        maxRetries = 3
-      } = this.props;
-      const { retryCount, errorId } = this.state;
-      if (fallback) {
-        return fallback;
-      }
-      return /* @__PURE__ */ jsx(
-        "div",
-        {
-          role: "alert",
-          className: "p-6 bg-destructive/10 border border-destructive/20 rounded-lg",
-          "data-error-boundary": errorId,
-          children: /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-3", children: [
-            /* @__PURE__ */ jsx("div", { className: "flex-shrink-0", children: /* @__PURE__ */ jsx("svg", { className: "w-5 h-5 text-destructive", viewBox: "0 0 20 20", fill: "currentColor", children: /* @__PURE__ */ jsx("path", { fillRule: "evenodd", d: "M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7 4a1 1 0 11-2 0 1 1 0 012 0zm-1-9a1 1 0 00-1 1v4a1 1 0 102 0V6a1 1 0 00-1-1z", clipRule: "evenodd" }) }) }),
-            /* @__PURE__ */ jsxs("div", { className: "flex-1 min-w-0", children: [
-              /* @__PURE__ */ jsxs("h3", { className: "text-destructive", children: [
-                "Error in ",
-                componentName
-              ] }),
-              /* @__PURE__ */ jsx("p", { className: "text-destructive/80", children: this.state.error?.message || "An unexpected error occurred." }),
-              enableRetry && retryCount < maxRetries && /* @__PURE__ */ jsxs("div", { className: "flex gap-3 mb-4", children: [
-                /* @__PURE__ */ jsxs(
-                  "button",
-                  {
-                    onClick: this.handleRetry,
-                    className: "px-4 py-2 bg-destructive text-destructive-foreground rounded-md hover:bg-destructive/90 transition-colors text-sm font-medium",
-                    children: [
-                      "Retry (",
-                      retryCount + 1,
-                      "/",
-                      maxRetries,
-                      ")"
-                    ]
-                  }
-                ),
-                /* @__PURE__ */ jsx(
-                  "button",
-                  {
-                    onClick: () => window.location.reload(),
-                    className: "px-4 py-2 bg-sec-600 text-main-50 rounded-md hover:bg-sec-700 transition-colors text-sm font-medium",
-                    children: "Reload Page"
-                  }
-                )
-              ] }),
-              retryCount >= maxRetries && /* @__PURE__ */ jsxs("div", { className: "mb-4 p-3 bg-acc-50 border border-acc-200 rounded-md", children: [
-                /* @__PURE__ */ jsx("p", { className: "text-acc-800", children: "Maximum retry attempts reached. Please reload the page or contact support." }),
-                /* @__PURE__ */ jsx(
-                  "button",
-                  {
-                    onClick: () => window.location.reload(),
-                    className: "mt-2 px-3 py-1 bg-acc-600 text-main-50 rounded text-sm hover:bg-acc-700",
-                    children: "Reload Page"
-                  }
-                )
-              ] }),
-              import.meta.env.MODE === "development" && this.state.error && /* @__PURE__ */ jsxs("details", { className: "text-sm text-destructive/70", children: [
-                /* @__PURE__ */ jsx("summary", { className: "cursor-pointer font-medium mb-2", children: "Error Details (Development)" }),
-                /* @__PURE__ */ jsxs("div", { className: "bg-destructive/5 p-3 rounded border", children: [
-                  /* @__PURE__ */ jsxs("p", { className: "font-mono", children: [
-                    "Error ID: ",
-                    errorId
-                  ] }),
-                  /* @__PURE__ */ jsxs("pre", { className: "whitespace-pre-wrap text-xs overflow-auto max-h-32", children: [
-                    this.state.error.toString(),
-                    this.state.errorInfo?.componentStack
-                  ] })
-                ] })
-              ] })
-            ] })
-          ] })
-        }
-      );
-    }
-    return this.props.children;
-  }
-};
-
-// src/components/PublicLayout/PublicPageProvider.tsx
-import { createContext, useContext, useMemo as useMemo2 } from "react";
-import { createClient } from "@supabase/supabase-js";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var PublicPageContext = createContext(void 0);
-function PublicPageProvider({ children, appName }) {
-  const getEnvVar = (key) => {
-    if (typeof import.meta !== "undefined" && import.meta.env) {
-      const env = import.meta.env;
-      return env[key];
-    }
-    if (typeof process !== "undefined" && process.env) {
-      return process.env[key];
-    }
-    return void 0;
-  };
-  const supabaseUrl = getEnvVar("VITE_SUPABASE_URL") || getEnvVar("NEXT_PUBLIC_SUPABASE_URL") || null;
-  const supabaseKey = getEnvVar("VITE_SUPABASE_ANON_KEY") || getEnvVar("NEXT_PUBLIC_SUPABASE_ANON_KEY") || null;
-  const supabase = useMemo2(() => {
-    if (!supabaseUrl || !supabaseKey) {
-      logger.warn("PublicPageProvider", "Missing Supabase environment variables. Please ensure VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY are set in your environment. Use publishable key if anon key is disabled.");
-      return null;
-    }
-    const client = createClient(supabaseUrl, supabaseKey);
-    logger.info("PublicPageProvider", "Supabase client created successfully for public pages");
-    return client;
-  }, [supabaseUrl, supabaseKey]);
-  const contextValue = {
-    isPublicPage: true,
-    supabase,
-    appName: appName || null,
-    environment: {
-      supabaseUrl,
-      supabaseKey
-    }
-  };
-  return /* @__PURE__ */ jsx2(PublicPageContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx2(ErrorBoundary, { componentName: "PublicPageProvider", children }) });
-}
-function usePublicPageContext() {
-  const context = useContext(PublicPageContext);
-  if (!context) {
-    throw new Error("usePublicPageContext must be used within a PublicPageProvider");
-  }
-  return context;
-}
-function useIsPublicPage() {
-  const context = useContext(PublicPageContext);
-  return context !== void 0;
-}
-
-// src/hooks/useAppConfig.ts
-import { useMemo as useMemo3, useContext as useContext2 } from "react";
-function useAppConfig() {
-  const isPublicPage = useIsPublicPage();
-  const publicPageContext = useContext2(PublicPageContext);
-  const contextAppName = publicPageContext?.appName || null;
-  if (isPublicPage) {
-    const getAppName = () => {
-      if (contextAppName) {
-        return contextAppName;
-      }
-      if (typeof import.meta !== "undefined" && import.meta.env) {
-        return import.meta.env.VITE_APP_NAME || import.meta.env.NEXT_PUBLIC_APP_NAME || "PACE";
-      }
-      if (typeof import.meta !== "undefined" && import.meta.env) {
-        return import.meta.env.VITE_APP_NAME || import.meta.env.NEXT_PUBLIC_APP_NAME || "PACE";
-      }
-      return "PACE";
-    };
-    return useMemo3(() => ({
-      supportsDirectAccess: false,
-      // Public pages don't support direct access
-      requiresEvent: true,
-      // Public pages always require an event
-      isLoading: false,
-      appName: getAppName()
-    }), [contextAppName]);
-  }
-  try {
-    const { appConfig, appName } = useUnifiedAuth();
-    return useMemo3(() => ({
-      supportsDirectAccess: !(appConfig?.requires_event ?? true),
-      requiresEvent: appConfig?.requires_event ?? true,
-      isLoading: appConfig === null,
-      appName
-    }), [appConfig?.requires_event, appName]);
-  } catch (error) {
-    return useMemo3(() => ({
-      supportsDirectAccess: false,
-      requiresEvent: true,
-      isLoading: false,
-      appName: "PACE"
-    }), []);
-  }
-}
-
 // src/utils/storage/config.ts
 var FILE_SIZE_LIMITS = {
   // Images
@@ -772,23 +451,24 @@ function validateFileSize(file) {
 }
 
 // src/utils/storage/helpers.ts
-var log3 = createLogger("StorageHelpers");
+var log2 = createLogger("StorageHelpers");
 function generateFilePath(options, fileName) {
-  const { orgId, isPublic = false, customPath } = options;
-  if (!orgId) {
-    throw new Error("orgId is required for file path generation");
+  const { orgId, userId, isPublic = false, customPath } = options;
+  if (!orgId && !userId) {
+    throw new Error("Either orgId or userId is required for file path generation");
   }
+  const basePath = orgId ? orgId : `users/${userId}`;
   if (isPublic) {
     if (customPath) {
-      return `${orgId}/${customPath}/${fileName}`;
+      return `${basePath}/${customPath}/${fileName}`;
     }
-    return `${orgId}/public/${fileName}`;
+    return `${basePath}/public/${fileName}`;
   }
   if (customPath) {
-    return `${orgId}/${customPath}/${fileName}`;
+    return `${basePath}/${customPath}/${fileName}`;
   }
   const pathFolder = customPath || "files";
-  return `${orgId}/${pathFolder}/${fileName}`;
+  return `${basePath}/${pathFolder}/${fileName}`;
 }
 function generateUniqueFileName(originalName) {
   const timestamp = Date.now();
@@ -805,7 +485,8 @@ async function extractFileMetadata(file, options, uploadedBy) {
   const metadata = {
     mimeType: file.type,
     size: file.size,
-    orgId: options.orgId,
+    ...options.orgId && { orgId: options.orgId },
+    ...options.userId && { userId: options.userId },
     appName: options.appName || "pace-core",
     uploadedBy,
     uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -867,12 +548,12 @@ async function ensureFolderExists(supabase, folderPath, bucketName) {
       contentType: "text/plain"
     });
     if (uploadError) {
-      log3.debug(`Could not create folder placeholder (will be created on upload): ${uploadError.message}`);
+      log2.debug(`Could not create folder placeholder (will be created on upload): ${uploadError.message}`);
       return true;
     }
     return true;
   } catch (error) {
-    log3.debug(`Folder creation exception (will be created on upload): ${error instanceof Error ? error.message : "Unknown error"}`);
+    log2.debug(`Folder creation exception (will be created on upload): ${error instanceof Error ? error.message : "Unknown error"}`);
     return true;
   }
 }
@@ -979,7 +660,7 @@ async function getSignedUrl(supabase, path, options) {
     const bucketName = getBucketName(false);
     const { data, error } = await supabase.storage.from(bucketName).createSignedUrl(path, options.expiresIn || 3600);
     if (error) {
-      log3.error("Failed to create signed URL:", error);
+      log2.error("Failed to create signed URL:", error);
       return null;
     }
     return {
@@ -987,7 +668,7 @@ async function getSignedUrl(supabase, path, options) {
       expiresAt: new Date(Date.now() + (options.expiresIn || 3600) * 1e3).toISOString()
     };
   } catch (error) {
-    log3.error("Failed to create signed URL:", error);
+    log2.error("Failed to create signed URL:", error);
     return null;
   }
 }
@@ -1049,7 +730,7 @@ async function generateFileUrlsBatch(supabase, fileReferences, options) {
         });
       }
     } catch (err) {
-      log3.error(`Failed to generate public URL for file ${file.id}:`, err);
+      log2.error(`Failed to generate public URL for file ${file.id}:`, err);
     }
   }
   if (privateFiles.length > 0) {
@@ -1070,7 +751,7 @@ async function generateFileUrlsBatch(supabase, fileReferences, options) {
         }
         return { id: file.id, url };
       } catch (err) {
-        log3.error(`Failed to generate signed URL for file ${file.id}:`, err);
+        log2.error(`Failed to generate signed URL for file ${file.id}:`, err);
         return { id: file.id, url: null };
       }
     });
@@ -1107,7 +788,11 @@ async function deleteFile(supabase, path, isPublic = false) {
 async function listFiles(supabase, options) {
   try {
     const bucketName = getBucketName(options.isPublic || false);
-    const pathPrefix = `${options.orgId}/`;
+    if (!options.orgId && !options.userId) {
+      throw new Error("Either orgId or userId is required for listing files");
+    }
+    const basePath = options.orgId ? options.orgId : `users/${options.userId}`;
+    const pathPrefix = `${basePath}/`;
     const searchPath = options.pathPrefix ? `${pathPrefix}${options.pathPrefix}` : pathPrefix;
     const { data, error } = await supabase.storage.from(bucketName).list(searchPath, {
       limit: options.limit || 100,
@@ -1115,7 +800,7 @@ async function listFiles(supabase, options) {
       sortBy: { column: "created_at", order: "desc" }
     });
     if (error) {
-      log3.error("Failed to list files:", error);
+      log2.error("Failed to list files:", error);
       return { files: [], totalCount: 0, hasMore: false };
     }
     const files = (data || []).map((item) => ({
@@ -1127,7 +812,8 @@ async function listFiles(supabase, options) {
       metadata: {
         mimeType: item.metadata?.mimetype || "application/octet-stream",
         size: item.metadata?.size || 0,
-        orgId: options.orgId,
+        ...options.orgId && { orgId: options.orgId },
+        ...options.userId && { userId: options.userId },
         appName: options.appName,
         uploadedBy: "unknown",
         uploadedAt: item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
@@ -1140,7 +826,7 @@ async function listFiles(supabase, options) {
       hasMore: files.length >= (options.limit || 100)
     };
   } catch (error) {
-    log3.error("Failed to list files:", error);
+    log2.error("Failed to list files:", error);
     return { files: [], totalCount: 0, hasMore: false };
   }
 }
@@ -1149,7 +835,7 @@ async function downloadFile(supabase, path, isPublic = false) {
     const bucketName = getBucketName(isPublic);
     const { data, error } = await supabase.storage.from(bucketName).download(path);
     if (error) {
-      log3.error("Failed to download file:", error);
+      log2.error("Failed to download file:", error);
       return null;
     }
     if (!data) {
@@ -1169,14 +855,21 @@ async function downloadFile(supabase, path, isPublic = false) {
       }
     };
   } catch (error) {
-    log3.error("Failed to download file:", error);
+    log2.error("Failed to download file:", error);
     return null;
   }
 }
 async function archiveFile(supabase, path, options) {
   try {
     const bucketName = getBucketName(options.isPublic || false);
-    const archivedPath = path.replace(`${options.orgId}/`, `archived/${options.orgId}/`);
+    let archivedPath;
+    if (options.orgId) {
+      archivedPath = path.replace(`${options.orgId}/`, `archived/${options.orgId}/`);
+    } else if (options.userId) {
+      archivedPath = path.replace(`users/${options.userId}/`, `archived/users/${options.userId}/`);
+    } else {
+      throw new Error("Either orgId or userId is required for archiving files");
+    }
     const { error: copyError } = await supabase.storage.from(bucketName).copy(path, archivedPath);
     if (copyError) {
       return {
@@ -1197,50 +890,378 @@ async function archiveFile(supabase, path, options) {
   }
 }
 
-// src/hooks/useFileDisplay.ts
-import { useState as useState3, useEffect as useEffect6, useCallback as useCallback3 } from "react";
-
-// src/utils/file-reference/index.ts
-var log4 = createLogger("FileReferenceService");
-var FileReferenceServiceImpl = class {
-  constructor(supabase) {
-    this.supabase = supabase;
-  }
-  /**
-   * Creates a file reference by uploading a file to storage and linking it in the database.
-   * 
-   * Storage Flow:
-   * 1. Upload file to storage bucket first (files or public-files based on is_public flag)
-   *    - Path format: {orgId}/{folder}/{timestamp-uuid-filename}
-   *    - Bucket selection: 'files' (private) or 'public-files' (public)
-   * 2. Extract file metadata (dimensions, hash, etc.)
-   * 3. Set organisation context for RLS policies
-   * 4. Create database reference via RPC function
-   * 5. If DB insert fails, rollback by deleting uploaded file
-   * 
-   * This ensures atomicity: either both storage and DB succeed, or both are cleaned up.
-   */
-  async createFileReference(options, file) {
-    try {
-      if (!options.organisation_id) {
-        throw new Error("organisation_id is required for file upload");
-      }
-      if (!options.table_name) {
-        throw new Error("table_name is required for file upload");
+// src/hooks/public/usePublicFileDisplay.ts
+import { useState as useState3, useEffect as useEffect4, useCallback as useCallback3 } from "react";
+var publicFileCache = /* @__PURE__ */ new Map();
+function usePublicFileDisplay(table_name, record_id, organisation_id, category, options) {
+  const {
+    cacheTtl = 30 * 60 * 1e3,
+    // 30 minutes
+    enableCache = true,
+    supabase
+  } = options;
+  const [fileUrl, setFileUrl] = useState3(null);
+  const [fileReference, setFileReference] = useState3(null);
+  const [fileReferences, setFileReferences] = useState3([]);
+  const [fileUrls, setFileUrls] = useState3(/* @__PURE__ */ new Map());
+  const [fileCount, setFileCount] = useState3(0);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const fetchFiles = useCallback3(async () => {
+    if (!table_name || !record_id || !supabase) {
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+      setIsLoading(false);
+      return;
+    }
+    if (organisation_id) {
+      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+      if (!uuidRegex.test(organisation_id)) {
+        logger.warn("usePublicFileDisplay", "Invalid organisationId format (not a valid UUID)", { organisation_id });
       }
-      if (!options.record_id) {
-        throw new Error("record_id is required for file upload");
+    }
+    const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id === void 0 ? "undefined" : organisation_id ?? "null"}_${category || "all"}`;
+    if (enableCache) {
+      const cached = publicFileCache.get(cacheKey);
+      if (cached && Date.now() - cached.timestamp < cached.ttl) {
+        const cachedData = cached.data;
+        setFileUrl(cachedData.fileUrl || null);
+        setFileReference(cachedData.fileReference || null);
+        setFileReferences(cachedData.fileReferences || []);
+        setFileUrls(cachedData.fileUrls || /* @__PURE__ */ new Map());
+        setFileCount(cachedData.fileCount || 0);
+        setIsLoading(false);
+        setError(null);
+        return;
       }
-      if (!options.folder) {
-        throw new Error("folder is required for file upload. The folder prop determines the storage path.");
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      let files = [];
+      if (organisation_id === void 0) {
+        logger.debug("usePublicFileDisplay", "organisation_id is undefined, searching both user-scoped and organisation-scoped files:", {
+          table_name,
+          record_id,
+          category
+        });
+        let userScopedFiles = [];
+        let orgScopedFiles = [];
+        if (category) {
+          const { data: userData, error: userRpcError } = await supabase.rpc("data_file_reference_by_category_list", {
+            p_table_name: table_name,
+            p_record_id: record_id,
+            p_category: category,
+            p_organisation_id: null
+          });
+          if (!userRpcError && userData) {
+            userScopedFiles = userData.filter((item) => item.is_public === true && item.id && item.file_path && item.file_metadata).map((item) => ({
+              id: item.id,
+              table_name,
+              record_id,
+              file_path: item.file_path,
+              file_metadata: item.file_metadata || {},
+              organisation_id: null,
+              app_id: item.file_metadata?.app_id || null,
+              is_public: true,
+              created_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+              updated_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString()
+            }));
+          }
+        } else {
+          const { data: userData, error: userRpcError } = await supabase.rpc("data_file_reference_list", {
+            p_table_name: table_name,
+            p_record_id: record_id,
+            p_organisation_id: null
+          });
+          if (!userRpcError && userData) {
+            const ids = userData.map((item) => item.id);
+            if (ids.length > 0) {
+              const { data: fullData } = await supabase.from("file_references").select("id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at").in("id", ids).eq("is_public", true);
+              userScopedFiles = fullData || [];
+            }
+          }
+        }
+        const allFiles = [...userScopedFiles, ...orgScopedFiles];
+        allFiles.sort((a, b) => {
+          const aTime = new Date(a.created_at).getTime();
+          const bTime = new Date(b.created_at).getTime();
+          return bTime - aTime;
+        });
+        files = allFiles;
+        logger.debug("usePublicFileDisplay", "Found files with undefined organisation_id:", {
+          userScopedCount: userScopedFiles.length,
+          orgScopedCount: orgScopedFiles.length,
+          totalCount: files.length
+        });
+      } else {
+        if (category) {
+          const rpcParams = {
+            p_table_name: table_name,
+            p_record_id: record_id,
+            p_category: category,
+            p_organisation_id: organisation_id ?? null
+          };
+          const { data, error: rpcError } = await supabase.rpc("data_file_reference_by_category_list", rpcParams);
+          if (rpcError) {
+            logger.error("usePublicFileDisplay", "RPC function error", {
+              function: "data_file_reference_by_category_list",
+              table_name,
+              record_id,
+              category,
+              organisation_id,
+              error: rpcError.message,
+              errorCode: rpcError.code,
+              errorDetails: rpcError.details,
+              errorHint: rpcError.hint
+            });
+            throw new Error(rpcError.message || "Failed to fetch file reference");
+          }
+          if (!data || data.length === 0) {
+            files = [];
+          } else {
+            files = data.filter((item) => {
+              return item.is_public === true && item.id && item.file_path && item.file_metadata;
+            }).map((item) => {
+              return {
+                id: item.id,
+                table_name,
+                record_id,
+                file_path: item.file_path,
+                file_metadata: item.file_metadata || {},
+                organisation_id: organisation_id ?? null,
+                app_id: item.file_metadata?.app_id || null,
+                is_public: true,
+                // RPC already filtered for public files
+                created_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+                updated_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString()
+              };
+            });
+          }
+        } else {
+          const { data: fileIds, error: rpcError } = await supabase.rpc("data_file_reference_list", {
+            p_table_name: table_name,
+            p_record_id: record_id,
+            p_organisation_id: organisation_id ?? null
+          });
+          if (rpcError) {
+            logger.error("usePublicFileDisplay", "RPC function error", {
+              function: "data_file_reference_list",
+              table_name,
+              record_id,
+              organisation_id,
+              error: rpcError.message,
+              errorCode: rpcError.code,
+              errorDetails: rpcError.details,
+              errorHint: rpcError.hint
+            });
+            throw new Error(rpcError.message || "Failed to fetch file references");
+          }
+          if (!fileIds || fileIds.length === 0) {
+            files = [];
+          } else {
+            const ids = fileIds.map((item) => item.id);
+            const { data: fullData, error: fetchError } = await supabase.from("file_references").select("id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at").in("id", ids).eq("is_public", true);
+            if (fetchError) {
+              throw new Error(fetchError.message || "Failed to fetch file references");
+            }
+            files = fullData || [];
+          }
+        }
       }
-      const uploadResult = await uploadFile(this.supabase, file, {
-        appName: "file-reference",
-        orgId: options.organisation_id,
-        isPublic: options.is_public || false,
-        customPath: options.folder
-        // Use folder prop as the custom path segment
-      });
+      const publicFiles = files.filter((f) => f.is_public === true);
+      if (publicFiles.length === 0) {
+        setFileUrl(null);
+        setFileReference(null);
+        setFileReferences([]);
+        setFileUrls(/* @__PURE__ */ new Map());
+        setFileCount(0);
+        if (enableCache) {
+          publicFileCache.set(cacheKey, {
+            data: { fileUrl: null, fileReference: null, fileReferences: [], fileUrls: /* @__PURE__ */ new Map(), fileCount: 0 },
+            timestamp: Date.now(),
+            ttl: cacheTtl
+          });
+        }
+        return;
+      }
+      const fileRefs = publicFiles.map((f) => ({
+        id: f.id,
+        table_name: f.table_name,
+        record_id: f.record_id,
+        file_path: f.file_path,
+        file_metadata: f.file_metadata || {},
+        organisation_id: f.organisation_id,
+        app_id: f.app_id,
+        is_public: f.is_public ?? true,
+        created_at: f.created_at,
+        updated_at: f.updated_at
+      }));
+      setFileReferences(fileRefs);
+      setFileCount(fileRefs.length);
+      if (category && fileRefs.length > 0) {
+        const firstFile = fileRefs[0];
+        setFileReference(firstFile);
+        const url = getPublicUrl(supabase, firstFile.file_path, true);
+        setFileUrl(url);
+      } else {
+        const urlMap = await generateFileUrlsBatch(supabase, fileRefs, {
+          appName: "pace-core",
+          orgId: organisation_id,
+          expiresIn: 3600
+        });
+        setFileUrls(urlMap);
+        setFileReference(null);
+        setFileUrl(null);
+      }
+      if (enableCache) {
+        publicFileCache.set(cacheKey, {
+          data: {
+            fileUrl: category ? fileRefs.length > 0 ? getPublicUrl(supabase, fileRefs[0].file_path, true) : null : null,
+            fileReference: category && fileRefs.length > 0 ? fileRefs[0] : null,
+            fileReferences: fileRefs,
+            fileUrls: category ? /* @__PURE__ */ new Map() : (() => {
+              const urlMap = /* @__PURE__ */ new Map();
+              for (const fileRef of fileRefs) {
+                const url = getPublicUrl(supabase, fileRef.file_path, true);
+                if (url) {
+                  urlMap.set(fileRef.id, url);
+                }
+              }
+              return urlMap;
+            })(),
+            fileCount: fileRefs.length
+          },
+          timestamp: Date.now(),
+          ttl: cacheTtl
+        });
+      }
+    } catch (err) {
+      logger.error("usePublicFileDisplay", "Error fetching files", {
+        table_name,
+        record_id,
+        organisation_id,
+        category,
+        error: err instanceof Error ? err.message : "Unknown error",
+        errorDetails: err instanceof Error ? err.stack : String(err)
+      });
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      setError(error2);
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
+  useEffect4(() => {
+    if (table_name && record_id) {
+      fetchFiles();
+    } else {
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+      setIsLoading(false);
+      setError(null);
+    }
+  }, [fetchFiles, table_name, record_id, organisation_id]);
+  const refetch = useCallback3(async () => {
+    if (!table_name || !record_id) return;
+    if (enableCache) {
+      const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id === void 0 ? "undefined" : organisation_id ?? "null"}_${category || "all"}`;
+      publicFileCache.delete(cacheKey);
+    }
+    await fetchFiles();
+  }, [fetchFiles, table_name, record_id, organisation_id, category, enableCache]);
+  return {
+    fileUrl,
+    fileReference,
+    fileReferences,
+    fileUrls,
+    fileCount,
+    isLoading,
+    error,
+    refetch
+  };
+}
+function clearPublicFileDisplayCache() {
+  for (const [key] of publicFileCache) {
+    if (key.startsWith("public_file_")) {
+      publicFileCache.delete(key);
+    }
+  }
+}
+function getPublicFileDisplayCacheStats() {
+  const keys = Array.from(publicFileCache.keys()).filter((key) => key.startsWith("public_file_"));
+  return {
+    size: keys.length,
+    keys
+  };
+}
+
+// src/hooks/useFileDisplay.ts
+import { useState as useState4, useEffect as useEffect5, useCallback as useCallback4 } from "react";
+
+// src/utils/file-reference/index.ts
+var log3 = createLogger("FileReferenceService");
+var FileReferenceServiceImpl = class {
+  constructor(supabase) {
+    this.supabase = supabase;
+  }
+  /**
+   * Creates a file reference by uploading a file to storage and linking it in the database.
+   * 
+   * Storage Flow:
+   * 1. Upload file to storage bucket first (files or public-files based on is_public flag)
+   *    - Path format: {orgId}/{folder}/{timestamp-uuid-filename}
+   *    - Bucket selection: 'files' (private) or 'public-files' (public)
+   * 2. Extract file metadata (dimensions, hash, etc.)
+   * 3. Set organisation context for RLS policies
+   * 4. Create database reference via RPC function
+   * 5. If DB insert fails, rollback by deleting uploaded file
+   * 
+   * This ensures atomicity: either both storage and DB succeed, or both are cleaned up.
+   */
+  async createFileReference(options, file) {
+    try {
+      const isUserScoped = !options.organisation_id && options.userId;
+      if (!isUserScoped && !options.organisation_id) {
+        throw new Error("organisation_id is required for file upload, or userId must be provided for user-scoped files");
+      }
+      if (!options.table_name) {
+        throw new Error("table_name is required for file upload");
+      }
+      if (!options.record_id) {
+        throw new Error("record_id is required for file upload");
+      }
+      if (!options.folder) {
+        throw new Error("folder is required for file upload. The folder prop determines the storage path.");
+      }
+      let authenticatedUserId = void 0;
+      if (isUserScoped) {
+        const { data: { user: authUser }, error: authError } = await this.supabase.auth.getUser();
+        if (authError || !authUser) {
+          throw new Error("User must be authenticated to upload user-scoped files");
+        }
+        authenticatedUserId = authUser.id;
+        log3.debug("Using authenticated user ID for user-scoped file upload", { userId: authenticatedUserId });
+      }
+      const uploadResult = await uploadFile(this.supabase, file, {
+        appName: "file-reference",
+        orgId: options.organisation_id || void 0,
+        userId: authenticatedUserId || (isUserScoped ? void 0 : options.userId),
+        // Use auth.uid() for user-scoped files
+        isPublic: options.is_public || false,
+        customPath: options.folder
+        // Use folder prop as the custom path segment
+      });
       if (!uploadResult.success) {
         throw new Error(`Failed to upload file: ${uploadResult.error}`);
       }
@@ -1250,16 +1271,20 @@ var FileReferenceServiceImpl = class {
       const filePath = uploadResult.path;
       const metadata = await extractFileMetadata(file, {
         appName: "file-reference",
-        orgId: options.organisation_id,
+        orgId: options.organisation_id || void 0,
+        userId: authenticatedUserId || (isUserScoped ? void 0 : options.userId),
+        // Use auth.uid() for user-scoped files
         isPublic: options.is_public || false
       }, "system");
-      await setOrganisationContext(this.supabase, options.organisation_id);
+      if (!isUserScoped && options.organisation_id) {
+        await setOrganisationContext(this.supabase, options.organisation_id);
+      }
       const { data, error } = await this.supabase.rpc("data_file_reference_create", {
         p_table_name: options.table_name,
         p_record_id: options.record_id,
         p_file_path: filePath,
         // Storage path from step 1
-        p_organisation_id: options.organisation_id,
+        p_organisation_id: options.organisation_id ?? null,
         p_app_id: options.app_id,
         p_page_context: options.pageContext,
         p_event_id: options.event_id || null,
@@ -1272,7 +1297,9 @@ var FileReferenceServiceImpl = class {
           ...metadata,
           ...options.custom_metadata
         },
-        p_is_public: options.is_public || false
+        p_is_public: options.is_public || false,
+        p_user_id: authenticatedUserId || options.userId || null
+        // Pass authenticated user ID for user-scoped files
       });
       if (error) {
         await deleteFile(this.supabase, filePath, options.is_public || false);
@@ -1290,18 +1317,24 @@ var FileReferenceServiceImpl = class {
       invalidateFileDisplayCache(
         options.table_name,
         options.record_id,
-        options.organisation_id,
+        options.organisation_id || null,
         options.category
       );
       return fileRef;
     } catch (error) {
-      log4.error("Error creating file reference:", error);
+      log3.error("Error creating file reference:", error);
       throw error;
     }
   }
   async getFileReference(table_name, record_id, organisation_id) {
     try {
-      const { data, error } = await this.supabase.from("file_references").select("id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at").eq("table_name", table_name).eq("record_id", record_id).eq("organisation_id", organisation_id).single();
+      let query = this.supabase.from("file_references").select("id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at").eq("table_name", table_name).eq("record_id", record_id);
+      if (organisation_id === null || organisation_id === void 0) {
+        query = query.is("organisation_id", null);
+      } else {
+        query = query.eq("organisation_id", organisation_id);
+      }
+      const { data, error } = await query.single();
       if (error) {
         if (error.code === "PGRST116") {
           return null;
@@ -1310,7 +1343,7 @@ var FileReferenceServiceImpl = class {
       }
       return data;
     } catch (error) {
-      log4.error("Error getting file reference:", error);
+      log3.error("Error getting file reference:", error);
       throw error;
     }
   }
@@ -1334,7 +1367,7 @@ var FileReferenceServiceImpl = class {
         return await this.getSignedUrl(table_name, record_id, organisation_id);
       }
     } catch (error) {
-      log4.error("Error getting file URL:", error);
+      log3.error("Error getting file URL:", error);
       throw error;
     }
   }
@@ -1343,7 +1376,7 @@ var FileReferenceServiceImpl = class {
       const { data: filePath, error } = await this.supabase.rpc("data_file_reference_signed_url_get", {
         p_table_name: table_name,
         p_record_id: record_id,
-        p_organisation_id: organisation_id,
+        p_organisation_id: organisation_id ?? null,
         p_expires_in: expires_in
       });
       if (error) {
@@ -1355,11 +1388,12 @@ var FileReferenceServiceImpl = class {
       const signedUrlResult = await getSignedUrl(this.supabase, filePath, {
         appName: "file-reference",
         orgId: organisation_id,
+        userId: organisation_id ? void 0 : record_id,
         expiresIn: expires_in
       });
       return signedUrlResult?.url || null;
     } catch (error) {
-      log4.error("Error getting signed URL:", error);
+      log3.error("Error getting signed URL:", error);
       throw error;
     }
   }
@@ -1371,7 +1405,7 @@ var FileReferenceServiceImpl = class {
       }
       return data;
     } catch (error) {
-      log4.error("Error updating file reference:", error);
+      log3.error("Error updating file reference:", error);
       throw error;
     }
   }
@@ -1381,7 +1415,7 @@ var FileReferenceServiceImpl = class {
       const { error } = await this.supabase.rpc("data_file_reference_delete", {
         p_table_name: table_name,
         p_record_id: record_id,
-        p_organisation_id: organisation_id,
+        p_organisation_id: organisation_id ?? null,
         p_delete_file: delete_file
       });
       if (error) {
@@ -1392,7 +1426,7 @@ var FileReferenceServiceImpl = class {
       }
       return true;
     } catch (error) {
-      log4.error("Error deleting file reference:", error);
+      log3.error("Error deleting file reference:", error);
       throw error;
     }
   }
@@ -1401,7 +1435,7 @@ var FileReferenceServiceImpl = class {
       const { data, error } = await this.supabase.rpc("data_file_reference_list", {
         p_table_name: table_name,
         p_record_id: record_id,
-        p_organisation_id: organisation_id
+        p_organisation_id: organisation_id ?? null
       });
       if (error) {
         throw new Error(`Failed to list file references: ${error.message}`);
@@ -1422,7 +1456,7 @@ var FileReferenceServiceImpl = class {
             fileType,
             ...item.file_metadata || {}
           },
-          organisation_id,
+          organisation_id: organisation_id ?? null,
           app_id: item.file_metadata?.app_id ? assertAppId(item.file_metadata.app_id) : assertAppId(""),
           // May not be in metadata, use empty string
           is_public: item.is_public ?? false,
@@ -1434,7 +1468,7 @@ var FileReferenceServiceImpl = class {
       });
       return fileReferences;
     } catch (error) {
-      log4.error("Error listing file references:", error);
+      log3.error("Error listing file references:", error);
       throw error;
     }
   }
@@ -1443,14 +1477,14 @@ var FileReferenceServiceImpl = class {
       const { data, error } = await this.supabase.rpc("data_file_reference_count_get", {
         p_table_name: table_name,
         p_record_id: record_id,
-        p_organisation_id: organisation_id
+        p_organisation_id: organisation_id ?? null
       });
       if (error) {
         throw new Error(`Failed to get file count: ${error.message}`);
       }
       return data || 0;
     } catch (error) {
-      log4.error("Error getting file count:", error);
+      log3.error("Error getting file count:", error);
       throw error;
     }
   }
@@ -1458,7 +1492,7 @@ var FileReferenceServiceImpl = class {
     try {
       const { data, error } = await this.supabase.rpc("data_file_reference_get", {
         p_file_reference_id: id,
-        p_organisation_id: organisation_id
+        p_organisation_id: organisation_id ?? null
       });
       if (error) {
         throw new Error(`Failed to get file reference by ID: ${error.message}`);
@@ -1468,7 +1502,7 @@ var FileReferenceServiceImpl = class {
       }
       return data[0];
     } catch (error) {
-      log4.error("Error getting file reference by ID:", error);
+      log3.error("Error getting file reference by ID:", error);
       throw error;
     }
   }
@@ -1478,10 +1512,10 @@ var FileReferenceServiceImpl = class {
         p_table_name: table_name,
         p_record_id: record_id,
         p_category: category,
-        p_organisation_id: organisation_id
+        p_organisation_id: organisation_id ?? null
       });
       if (error) {
-        log4.error("RPC ERROR getting files by category:", {
+        log3.error("RPC ERROR getting files by category:", {
           error,
           errorCode: error.code,
           errorMessage: error.message,
@@ -1501,7 +1535,7 @@ var FileReferenceServiceImpl = class {
         const fileCategory = item.file_metadata?.category;
         const matches = fileCategory === category;
         if (!matches) {
-          log4.warn("File category mismatch in RPC response:", {
+          log3.warn("File category mismatch in RPC response:", {
             fileId: item.id,
             expectedCategory: category,
             actualCategory: fileCategory
@@ -1522,7 +1556,7 @@ var FileReferenceServiceImpl = class {
             category: item.file_metadata?.category || "general_documents" /* GENERAL_DOCUMENTS */,
             ...item.file_metadata || {}
           },
-          organisation_id,
+          organisation_id: organisation_id ?? null,
           app_id: item.file_metadata?.app_id ? assertAppId(item.file_metadata.app_id) : assertAppId(""),
           // May not be in metadata, use empty string
           is_public: item.is_public ?? false,
@@ -1534,7 +1568,7 @@ var FileReferenceServiceImpl = class {
       });
       return fileReferences;
     } catch (error) {
-      log4.error("Error getting files by category:", error);
+      log3.error("Error getting files by category:", error);
       throw error;
     }
   }
@@ -1576,7 +1610,8 @@ async function uploadFileWithReference(supabase, options, file) {
   const fileReference = await service.createFileReference(options, file);
   const fileUrl = options.is_public ? getPublicUrl(supabase, fileReference.file_path, true) : await getSignedUrl(supabase, fileReference.file_path, {
     appName: "file-reference",
-    orgId: options.organisation_id,
+    orgId: options.organisation_id || void 0,
+    userId: options.userId || void 0,
     expiresIn: 3600
   });
   const urlString = typeof fileUrl === "string" ? fileUrl : fileUrl?.url || "";
@@ -1613,15 +1648,15 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
     enableCache = true,
     supabase
   } = options;
-  const [fileUrl, setFileUrl] = useState3(null);
-  const [fileReference, setFileReference] = useState3(null);
-  const [fileReferences, setFileReferences] = useState3([]);
-  const [fileUrls, setFileUrls] = useState3(/* @__PURE__ */ new Map());
-  const [fileCount, setFileCount] = useState3(0);
-  const [isLoading, setIsLoading] = useState3(false);
-  const [error, setError] = useState3(null);
-  const fetchFiles = useCallback3(async () => {
-    if (!table_name || !record_id || !organisation_id || !supabase) {
+  const [fileUrl, setFileUrl] = useState4(null);
+  const [fileReference, setFileReference] = useState4(null);
+  const [fileReferences, setFileReferences] = useState4([]);
+  const [fileUrls, setFileUrls] = useState4(/* @__PURE__ */ new Map());
+  const [fileCount, setFileCount] = useState4(0);
+  const [isLoading, setIsLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const fetchFiles = useCallback4(async () => {
+    if (!table_name || !record_id || !supabase) {
       setFileUrl(null);
       setFileReference(null);
       setFileReferences([]);
@@ -1630,11 +1665,13 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
       setIsLoading(false);
       return;
     }
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    if (!uuidRegex.test(organisation_id)) {
-      logger.warn("useFileDisplay", "Invalid organisationId format (not a valid UUID):", organisation_id);
+    if (organisation_id) {
+      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+      if (!uuidRegex.test(organisation_id)) {
+        logger.warn("useFileDisplay", "Invalid organisationId format (not a valid UUID):", organisation_id);
+      }
     }
-    const cacheKey = `file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+    const cacheKey = `file_${table_name}_${record_id}_${organisation_id === void 0 ? "undefined" : organisation_id ?? "null"}_${category || "all"}`;
     if (enableCache) {
       const cached = authenticatedFileCache.get(cacheKey);
       if (cached && Date.now() - cached.timestamp < cached.ttl) {
@@ -1644,6 +1681,7 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
             const signedUrlResult = await getSignedUrl(supabase, cachedData.fileReference.file_path, {
               appName: "pace-core",
               orgId: organisation_id,
+              userId: organisation_id ? void 0 : record_id,
               expiresIn: 3600
             });
             const regeneratedUrl = signedUrlResult?.url || null;
@@ -1674,25 +1712,205 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
       setError(null);
       const service = createFileReferenceService(supabase);
       let files = [];
-      if (category) {
-        logger.debug("useFileDisplay", "Using RPC function for category filtering:", {
-          table_name,
-          record_id,
-          category,
-          organisation_id
+      const shouldSearchBothScopes = organisation_id === void 0;
+      if (shouldSearchBothScopes) {
+        let userScopedFiles = [];
+        let orgScopedFiles = [];
+        try {
+          if (category) {
+            userScopedFiles = await service.getFilesByCategory(
+              table_name,
+              record_id,
+              category,
+              void 0
+              // Explicitly pass undefined for user-scoped files (service converts to null for RPC)
+            );
+          } else {
+            userScopedFiles = await service.listFileReferences(
+              table_name,
+              record_id,
+              void 0
+              // Explicitly pass undefined for user-scoped files (service converts to null for RPC)
+            );
+          }
+        } catch (err) {
+          logger.warn("useFileDisplay", "Error querying user-scoped files:", err);
+          userScopedFiles = [];
+        }
+        try {
+          const { data: { user }, error: userError } = await supabase.auth.getUser();
+          if (userError) {
+            logger.warn("useFileDisplay", "Error getting user:", userError);
+          }
+          if (user) {
+            const { data: memberships, error: membershipError } = await supabase.from("organisation_memberships").select("organisation_id").eq("user_id", user.id).or("status.is.null,status.eq.active");
+            if (membershipError) {
+              logger.warn("useFileDisplay", "Error querying organisation memberships:", membershipError);
+            }
+            if (memberships && memberships.length > 0) {
+              const orgIds = memberships.map((m) => m.organisation_id).filter(Boolean);
+              const orgQueries = orgIds.map(async (orgId) => {
+                try {
+                  if (category) {
+                    return await service.getFilesByCategory(
+                      table_name,
+                      record_id,
+                      category,
+                      orgId
+                    );
+                  } else {
+                    return await service.listFileReferences(
+                      table_name,
+                      record_id,
+                      orgId
+                    );
+                  }
+                } catch (err) {
+                  return [];
+                }
+              });
+              const orgResults = await Promise.all(orgQueries);
+              orgScopedFiles = orgResults.flat();
+            } else {
+              try {
+                let fallbackQuery = supabase.from("file_references").select("id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at").eq("table_name", table_name).eq("record_id", record_id).order("created_at", { ascending: false });
+                if (category) {
+                  fallbackQuery = fallbackQuery.eq("file_metadata->>category", category);
+                }
+                const { data: fallbackFiles } = await fallbackQuery;
+                if (fallbackFiles && fallbackFiles.length > 0) {
+                  orgScopedFiles = fallbackFiles.map((f) => ({
+                    id: f.id,
+                    table_name: f.table_name,
+                    record_id: f.record_id,
+                    file_path: f.file_path,
+                    file_metadata: f.file_metadata || {},
+                    organisation_id: f.organisation_id,
+                    app_id: f.app_id,
+                    is_public: f.is_public ?? false,
+                    created_at: f.created_at,
+                    updated_at: f.updated_at
+                  }));
+                }
+              } catch (err) {
+              }
+            }
+          }
+        } catch (err) {
+          logger.warn("useFileDisplay", "Error querying organisation-scoped files:", err);
+          orgScopedFiles = [];
+        }
+        const allFiles = [...userScopedFiles, ...orgScopedFiles];
+        allFiles.sort((a, b) => {
+          const aTime = new Date(a.created_at).getTime();
+          const bTime = new Date(b.created_at).getTime();
+          return bTime - aTime;
         });
-        files = await service.getFilesByCategory(
-          table_name,
-          record_id,
-          category,
-          organisation_id
-        );
+        if (orgScopedFiles.length > 0 && userScopedFiles.length > 0) {
+          files = allFiles.filter((f) => f.organisation_id !== null);
+        } else {
+          files = allFiles;
+        }
+        if (files.length === 0) {
+          try {
+            let directQuery = supabase.from("file_references").select("id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at").eq("table_name", table_name).eq("record_id", record_id).order("created_at", { ascending: false });
+            if (category) {
+              directQuery = directQuery.eq("file_metadata->>category", category);
+            }
+            const { data: directFiles } = await directQuery;
+            if (directFiles && directFiles.length > 0) {
+              files = directFiles.map((f) => ({
+                id: f.id,
+                table_name: f.table_name,
+                record_id: f.record_id,
+                file_path: f.file_path,
+                file_metadata: f.file_metadata || {},
+                organisation_id: f.organisation_id,
+                app_id: f.app_id,
+                is_public: f.is_public ?? false,
+                created_at: f.created_at,
+                updated_at: f.updated_at
+              }));
+            }
+          } catch (err) {
+          }
+        }
       } else {
-        files = await service.listFileReferences(
-          table_name,
-          record_id,
-          organisation_id
-        );
+        if (category) {
+          logger.debug("useFileDisplay", "Using RPC function for category filtering:", {
+            table_name,
+            record_id,
+            category,
+            organisation_id
+          });
+          files = await service.getFilesByCategory(
+            table_name,
+            record_id,
+            category,
+            organisation_id
+          );
+        } else {
+          files = await service.listFileReferences(
+            table_name,
+            record_id,
+            organisation_id
+          );
+        }
+        if (files.length === 0 && (!organisation_id || organisation_id === "")) {
+          let userScopedFiles = [];
+          let orgScopedFiles = [];
+          try {
+            if (category) {
+              userScopedFiles = await service.getFilesByCategory(
+                table_name,
+                record_id,
+                category,
+                void 0
+              );
+            } else {
+              userScopedFiles = await service.listFileReferences(
+                table_name,
+                record_id,
+                void 0
+              );
+            }
+          } catch (err) {
+          }
+          try {
+            const { data: { user } } = await supabase.auth.getUser();
+            if (user) {
+              const { data: memberships } = await supabase.from("organisation_memberships").select("organisation_id").eq("user_id", user.id).or("status.is.null,status.eq.active");
+              if (memberships && memberships.length > 0) {
+                const orgIds = memberships.map((m) => m.organisation_id).filter(Boolean);
+                const orgQueries = orgIds.map(async (orgId) => {
+                  try {
+                    if (category) {
+                      return await service.getFilesByCategory(table_name, record_id, category, orgId);
+                    } else {
+                      return await service.listFileReferences(table_name, record_id, orgId);
+                    }
+                  } catch (err) {
+                    return [];
+                  }
+                });
+                const orgResults = await Promise.all(orgQueries);
+                orgScopedFiles = orgResults.flat();
+              }
+            }
+          } catch (err) {
+          }
+          const allFiles = [...userScopedFiles, ...orgScopedFiles];
+          allFiles.sort((a, b) => {
+            const aTime = new Date(a.created_at).getTime();
+            const bTime = new Date(b.created_at).getTime();
+            return bTime - aTime;
+          });
+          if (orgScopedFiles.length > 0 && userScopedFiles.length > 0) {
+            files = allFiles.filter((f) => f.organisation_id !== null);
+          } else {
+            files = allFiles;
+          }
+        }
       }
       if (files.length === 0) {
         setFileUrl(null);
@@ -1730,6 +1948,7 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
           const signedUrlResult = await getSignedUrl(supabase, firstFile.file_path, {
             appName: "pace-core",
             orgId: organisation_id,
+            userId: organisation_id ? void 0 : record_id,
             expiresIn: 3600
           });
           url = signedUrlResult?.url || null;
@@ -1741,6 +1960,7 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
         const urlMap = await generateFileUrlsBatch(supabase, files, {
           appName: "pace-core",
           orgId: organisation_id,
+          userId: organisation_id ? void 0 : record_id,
           expiresIn: 3600
         });
         setFileUrls(urlMap);
@@ -1793,8 +2013,8 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
       setIsLoading(false);
     }
   }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
-  useEffect6(() => {
-    if (table_name && record_id && organisation_id && supabase) {
+  useEffect5(() => {
+    if (table_name && record_id && supabase) {
       fetchFiles();
     } else {
       setFileUrl(null);
@@ -1805,11 +2025,11 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
       setIsLoading(false);
       setError(null);
     }
-  }, [fetchFiles, table_name, record_id, organisation_id, supabase]);
-  const refetch = useCallback3(async () => {
-    if (!table_name || !record_id || !organisation_id || !supabase) return;
+  }, [table_name, record_id, organisation_id, supabase]);
+  const refetch = useCallback4(async () => {
+    if (!table_name || !record_id || !supabase) return;
     if (enableCache) {
-      const cacheKey = `file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+      const cacheKey = `file_${table_name}_${record_id}_${organisation_id === void 0 ? "undefined" : organisation_id ?? "null"}_${category || "all"}`;
       authenticatedFileCache.delete(cacheKey);
     }
     await fetchFiles();
@@ -1840,284 +2060,109 @@ function getFileDisplayCacheStats() {
   };
 }
 function invalidateFileDisplayCache(table_name, record_id, organisation_id, category) {
-  const cacheKey = `file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+  const cacheKey = `file_${table_name}_${record_id}_${organisation_id === void 0 ? "undefined" : organisation_id ?? "null"}_${category || "all"}`;
   authenticatedFileCache.delete(cacheKey);
   if (category) {
-    const allCategoryKey = `file_${table_name}_${record_id}_${organisation_id}_all`;
+    const allCategoryKey = `file_${table_name}_${record_id}_${organisation_id === void 0 ? "undefined" : organisation_id ?? "null"}_all`;
     authenticatedFileCache.delete(allCategoryKey);
   }
 }
 
-// src/hooks/public/usePublicFileDisplay.ts
-import { useState as useState4, useEffect as useEffect7, useCallback as useCallback4 } from "react";
-var publicFileCache = /* @__PURE__ */ new Map();
-function usePublicFileDisplay(table_name, record_id, organisation_id, category, options) {
-  const {
-    cacheTtl = 30 * 60 * 1e3,
-    // 30 minutes
-    enableCache = true,
-    supabase
-  } = options;
-  const [fileUrl, setFileUrl] = useState4(null);
-  const [fileReference, setFileReference] = useState4(null);
-  const [fileReferences, setFileReferences] = useState4([]);
-  const [fileUrls, setFileUrls] = useState4(/* @__PURE__ */ new Map());
-  const [fileCount, setFileCount] = useState4(0);
-  const [isLoading, setIsLoading] = useState4(false);
-  const [error, setError] = useState4(null);
-  const fetchFiles = useCallback4(async () => {
-    if (!table_name || !record_id || !organisation_id || !supabase) {
-      setFileUrl(null);
-      setFileReference(null);
-      setFileReferences([]);
-      setFileUrls(/* @__PURE__ */ new Map());
-      setFileCount(0);
-      setIsLoading(false);
+// src/hooks/useEventTheme.ts
+import { useEffect as useEffect6 } from "react";
+import { useLocation } from "react-router-dom";
+var log4 = createLogger("useEventTheme");
+function useEventTheme(event) {
+  const location = useLocation();
+  let selectedEvent;
+  try {
+    if (event === void 0) {
+      const eventsContext = useEvents();
+      selectedEvent = eventsContext.selectedEvent;
+    } else {
+      selectedEvent = event;
+    }
+  } catch (error) {
+    if (event !== void 0) {
+      selectedEvent = event;
+    } else {
+      selectedEvent = null;
+    }
+  }
+  useEffect6(() => {
+    const isOnLoginRoute = location.pathname === "/login" || location.pathname.startsWith("/login");
+    if (isOnLoginRoute) {
+      clearPalette();
       return;
     }
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    if (!uuidRegex.test(organisation_id)) {
-      logger.warn("usePublicFileDisplay", "Invalid organisationId format (not a valid UUID)", { organisation_id });
+    if (!selectedEvent) {
+      clearPalette();
+      return;
     }
-    const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
-    if (enableCache) {
-      const cached = publicFileCache.get(cacheKey);
-      if (cached && Date.now() - cached.timestamp < cached.ttl) {
-        const cachedData = cached.data;
-        setFileUrl(cachedData.fileUrl || null);
-        setFileReference(cachedData.fileReference || null);
-        setFileReferences(cachedData.fileReferences || []);
-        setFileUrls(cachedData.fileUrls || /* @__PURE__ */ new Map());
-        setFileCount(cachedData.fileCount || 0);
-        setIsLoading(false);
-        setError(null);
-        return;
-      }
+    const eventColours = selectedEvent.event_colours;
+    const normalized = parseAndNormalizeEventColours(eventColours);
+    if (!normalized) {
+      clearPalette();
+      return;
     }
     try {
-      setIsLoading(true);
-      setError(null);
-      let files = [];
-      if (category) {
-        const rpcParams = {
-          p_table_name: table_name,
-          p_record_id: record_id,
-          p_category: category,
-          p_organisation_id: organisation_id
-        };
-        const { data, error: rpcError } = await supabase.rpc("data_file_reference_by_category_list", rpcParams);
-        if (rpcError) {
-          logger.error("usePublicFileDisplay", "RPC function error", {
-            function: "data_file_reference_by_category_list",
-            table_name,
-            record_id,
-            category,
-            organisation_id,
-            error: rpcError.message,
-            errorCode: rpcError.code,
-            errorDetails: rpcError.details,
-            errorHint: rpcError.hint
-          });
-          throw new Error(rpcError.message || "Failed to fetch file reference");
-        }
-        if (!data || data.length === 0) {
-          files = [];
-        } else {
-          files = data.filter((item) => {
-            return item.is_public === true && item.id && item.file_path && item.file_metadata;
-          }).map((item) => {
-            return {
-              id: item.id,
-              table_name,
-              record_id,
-              file_path: item.file_path,
-              file_metadata: item.file_metadata || {},
-              organisation_id,
-              app_id: item.file_metadata?.app_id || null,
-              is_public: true,
-              // RPC already filtered for public files
-              created_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
-              updated_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString()
-            };
-          });
-        }
-      } else {
-        const { data: fileIds, error: rpcError } = await supabase.rpc("data_file_reference_list", {
-          p_table_name: table_name,
-          p_record_id: record_id,
-          p_organisation_id: organisation_id
-        });
-        if (rpcError) {
-          logger.error("usePublicFileDisplay", "RPC function error", {
-            function: "data_file_reference_list",
-            table_name,
-            record_id,
-            organisation_id,
-            error: rpcError.message,
-            errorCode: rpcError.code,
-            errorDetails: rpcError.details,
-            errorHint: rpcError.hint
-          });
-          throw new Error(rpcError.message || "Failed to fetch file references");
-        }
-        if (!fileIds || fileIds.length === 0) {
-          files = [];
-        } else {
-          const ids = fileIds.map((item) => item.id);
-          const { data: fullData, error: fetchError } = await supabase.from("file_references").select("id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at").in("id", ids).eq("is_public", true);
-          if (fetchError) {
-            throw new Error(fetchError.message || "Failed to fetch file references");
-          }
-          files = fullData || [];
+      applyPalette(normalized);
+    } catch (error) {
+      log4.error("Failed to apply event palette:", error);
+    }
+    return () => {
+    };
+  }, [selectedEvent, location.pathname]);
+}
+
+// src/hooks/usePreventTabReload.ts
+import { useEffect as useEffect7, useRef as useRef3 } from "react";
+function usePreventTabReload(options = {}) {
+  const { enabled = true, gracePeriodMs = 2e3 } = options;
+  const isRestoringFromCacheRef = useRef3(false);
+  const gracePeriodTimeoutRef = useRef3(null);
+  useEffect7(() => {
+    if (!enabled || typeof window === "undefined") return;
+    const handlePageShow = (event) => {
+      if (event.persisted) {
+        isRestoringFromCacheRef.current = true;
+        if (gracePeriodTimeoutRef.current) {
+          clearTimeout(gracePeriodTimeoutRef.current);
         }
+        gracePeriodTimeoutRef.current = setTimeout(() => {
+          isRestoringFromCacheRef.current = false;
+        }, gracePeriodMs);
       }
-      const publicFiles = files.filter((f) => f.is_public === true);
-      if (publicFiles.length === 0) {
-        setFileUrl(null);
-        setFileReference(null);
-        setFileReferences([]);
-        setFileUrls(/* @__PURE__ */ new Map());
-        setFileCount(0);
-        if (enableCache) {
-          publicFileCache.set(cacheKey, {
-            data: { fileUrl: null, fileReference: null, fileReferences: [], fileUrls: /* @__PURE__ */ new Map(), fileCount: 0 },
-            timestamp: Date.now(),
-            ttl: cacheTtl
-          });
+    };
+    const handleVisibilityChange = () => {
+      if (!document.hidden) {
+        isRestoringFromCacheRef.current = true;
+        if (gracePeriodTimeoutRef.current) {
+          clearTimeout(gracePeriodTimeoutRef.current);
         }
-        return;
-      }
-      const fileRefs = publicFiles.map((f) => ({
-        id: f.id,
-        table_name: f.table_name,
-        record_id: f.record_id,
-        file_path: f.file_path,
-        file_metadata: f.file_metadata || {},
-        organisation_id: f.organisation_id,
-        app_id: f.app_id,
-        is_public: f.is_public ?? true,
-        created_at: f.created_at,
-        updated_at: f.updated_at
-      }));
-      setFileReferences(fileRefs);
-      setFileCount(fileRefs.length);
-      if (category && fileRefs.length > 0) {
-        const firstFile = fileRefs[0];
-        setFileReference(firstFile);
-        const url = getPublicUrl(supabase, firstFile.file_path, true);
-        setFileUrl(url);
-      } else {
-        const urlMap = await generateFileUrlsBatch(supabase, fileRefs, {
-          appName: "pace-core",
-          orgId: organisation_id,
-          expiresIn: 3600
-        });
-        setFileUrls(urlMap);
-        setFileReference(null);
-        setFileUrl(null);
+        gracePeriodTimeoutRef.current = setTimeout(() => {
+          isRestoringFromCacheRef.current = false;
+        }, gracePeriodMs);
       }
-      if (enableCache) {
-        publicFileCache.set(cacheKey, {
-          data: {
-            fileUrl: category ? fileRefs.length > 0 ? getPublicUrl(supabase, fileRefs[0].file_path, true) : null : null,
-            fileReference: category && fileRefs.length > 0 ? fileRefs[0] : null,
-            fileReferences: fileRefs,
-            fileUrls: category ? /* @__PURE__ */ new Map() : (() => {
-              const urlMap = /* @__PURE__ */ new Map();
-              for (const fileRef of fileRefs) {
-                const url = getPublicUrl(supabase, fileRef.file_path, true);
-                if (url) {
-                  urlMap.set(fileRef.id, url);
-                }
-              }
-              return urlMap;
-            })(),
-            fileCount: fileRefs.length
-          },
-          timestamp: Date.now(),
-          ttl: cacheTtl
-        });
+    };
+    window.addEventListener("pageshow", handlePageShow);
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      window.removeEventListener("pageshow", handlePageShow);
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+      if (gracePeriodTimeoutRef.current) {
+        clearTimeout(gracePeriodTimeoutRef.current);
       }
-    } catch (err) {
-      logger.error("usePublicFileDisplay", "Error fetching files", {
-        table_name,
-        record_id,
-        organisation_id,
-        category,
-        error: err instanceof Error ? err.message : "Unknown error",
-        errorDetails: err instanceof Error ? err.stack : String(err)
-      });
-      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
-      setError(error2);
-      setFileUrl(null);
-      setFileReference(null);
-      setFileReferences([]);
-      setFileUrls(/* @__PURE__ */ new Map());
-      setFileCount(0);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
-  useEffect7(() => {
-    if (table_name && record_id && organisation_id) {
-      fetchFiles();
-    } else {
-      setFileUrl(null);
-      setFileReference(null);
-      setFileReferences([]);
-      setFileUrls(/* @__PURE__ */ new Map());
-      setFileCount(0);
-      setIsLoading(false);
-      setError(null);
-    }
-  }, [fetchFiles, table_name, record_id, organisation_id]);
-  const refetch = useCallback4(async () => {
-    if (!table_name || !record_id || !organisation_id) return;
-    if (enableCache) {
-      const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
-      publicFileCache.delete(cacheKey);
-    }
-    await fetchFiles();
-  }, [fetchFiles, table_name, record_id, organisation_id, category, enableCache]);
-  return {
-    fileUrl,
-    fileReference,
-    fileReferences,
-    fileUrls,
-    fileCount,
-    isLoading,
-    error,
-    refetch
-  };
-}
-function clearPublicFileDisplayCache() {
-  for (const [key] of publicFileCache) {
-    if (key.startsWith("public_file_")) {
-      publicFileCache.delete(key);
-    }
-  }
-}
-function getPublicFileDisplayCacheStats() {
-  const keys = Array.from(publicFileCache.keys()).filter((key) => key.startsWith("public_file_"));
-  return {
-    size: keys.length,
-    keys
-  };
+    };
+  }, [enabled, gracePeriodMs]);
 }
 
 export {
   useDebounce,
+  cleanupQueryCache,
   useQueryCache,
   queryCacheHelpers,
   useAddressAutocomplete,
-  useEventTheme,
-  usePreventTabReload,
-  ErrorBoundary,
-  PublicPageContext,
-  PublicPageProvider,
-  usePublicPageContext,
-  useIsPublicPage,
-  useAppConfig,
   FILE_SIZE_LIMITS,
   DEFAULT_FILE_SIZE_LIMIT,
   APP_PATH_MAPPING,
@@ -2136,14 +2181,16 @@ export {
   listFiles,
   downloadFile,
   archiveFile,
+  usePublicFileDisplay,
+  clearPublicFileDisplayCache,
+  getPublicFileDisplayCacheStats,
+  createFileReferenceService,
+  uploadFileWithReference,
   useFileDisplay,
   clearFileDisplayCache,
   getFileDisplayCacheStats,
   invalidateFileDisplayCache,
-  createFileReferenceService,
-  uploadFileWithReference,
-  usePublicFileDisplay,
-  clearPublicFileDisplayCache,
-  getPublicFileDisplayCacheStats
+  useEventTheme,
+  usePreventTabReload
 };
-//# sourceMappingURL=chunk-UNOTYLQF.js.map
+//# sourceMappingURL=chunk-NIU6J6OX.js.map