@jmruthers/pace-core 0.5.189 → 0.5.190

package/dist/{chunk-UCQSRW7Z.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 = {}) => {
@@ -443,21 +453,22 @@ function validateFileSize(file) {
 // src/utils/storage/helpers.ts
 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();
@@ -474,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(),
@@ -776,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,
@@ -796,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(),
@@ -845,7 +862,14 @@ async function downloadFile(supabase, path, isPublic = false) {
 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 {
@@ -884,7 +908,7 @@ function usePublicFileDisplay(table_name, record_id, organisation_id, category,
   const [isLoading, setIsLoading] = useState3(false);
   const [error, setError] = useState3(null);
   const fetchFiles = useCallback3(async () => {
-    if (!table_name || !record_id || !organisation_id || !supabase) {
+    if (!table_name || !record_id || !supabase) {
       setFileUrl(null);
       setFileReference(null);
       setFileReferences([]);
@@ -893,11 +917,13 @@ function usePublicFileDisplay(table_name, record_id, organisation_id, category,
       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("usePublicFileDisplay", "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("usePublicFileDisplay", "Invalid organisationId format (not a valid UUID)", { organisation_id });
+      }
     }
-    const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+    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) {
@@ -916,77 +942,134 @@ function usePublicFileDisplay(table_name, record_id, organisation_id, category,
       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
+      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
           });
-          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 {
+          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,
+              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: 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 || [];
+            }
+          }
         }
-      } 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
+        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 (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 = [];
+        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 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");
+          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 || [];
           }
-          files = fullData || [];
         }
       }
       const publicFiles = files.filter((f) => f.is_public === true);
@@ -1077,7 +1160,7 @@ function usePublicFileDisplay(table_name, record_id, organisation_id, category,
     }
   }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
   useEffect4(() => {
-    if (table_name && record_id && organisation_id) {
+    if (table_name && record_id) {
       fetchFiles();
     } else {
       setFileUrl(null);
@@ -1090,9 +1173,9 @@ function usePublicFileDisplay(table_name, record_id, organisation_id, category,
     }
   }, [fetchFiles, table_name, record_id, organisation_id]);
   const refetch = useCallback3(async () => {
-    if (!table_name || !record_id || !organisation_id) return;
+    if (!table_name || !record_id) return;
     if (enableCache) {
-      const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+      const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id === void 0 ? "undefined" : organisation_id ?? "null"}_${category || "all"}`;
       publicFileCache.delete(cacheKey);
     }
     await fetchFiles();
@@ -1148,8 +1231,9 @@ var FileReferenceServiceImpl = class {
    */
   async createFileReference(options, file) {
     try {
-      if (!options.organisation_id) {
-        throw new Error("organisation_id is required for file upload");
+      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");
@@ -1160,9 +1244,20 @@ var FileReferenceServiceImpl = class {
       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,
+        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
@@ -1176,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,
@@ -1198,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);
@@ -1216,7 +1317,7 @@ var FileReferenceServiceImpl = class {
       invalidateFileDisplayCache(
         options.table_name,
         options.record_id,
-        options.organisation_id,
+        options.organisation_id || null,
         options.category
       );
       return fileRef;
@@ -1227,7 +1328,13 @@ var FileReferenceServiceImpl = class {
   }
   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;
@@ -1269,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) {
@@ -1281,6 +1388,7 @@ 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;
@@ -1307,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) {
@@ -1327,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}`);
@@ -1348,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,
@@ -1369,7 +1477,7 @@ 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}`);
@@ -1384,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}`);
@@ -1404,7 +1512,7 @@ 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) {
         log3.error("RPC ERROR getting files by category:", {
@@ -1448,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,
@@ -1502,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 || "";
@@ -1547,7 +1656,7 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
   const [isLoading, setIsLoading] = useState4(false);
   const [error, setError] = useState4(null);
   const fetchFiles = useCallback4(async () => {
-    if (!table_name || !record_id || !organisation_id || !supabase) {
+    if (!table_name || !record_id || !supabase) {
       setFileUrl(null);
       setFileReference(null);
       setFileReferences([]);
@@ -1556,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) {
@@ -1570,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;
@@ -1600,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);
@@ -1656,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;
@@ -1667,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);
@@ -1720,7 +2014,7 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
     }
   }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
   useEffect5(() => {
-    if (table_name && record_id && organisation_id && supabase) {
+    if (table_name && record_id && supabase) {
       fetchFiles();
     } else {
       setFileUrl(null);
@@ -1731,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]);
+  }, [table_name, record_id, organisation_id, supabase]);
   const refetch = useCallback4(async () => {
-    if (!table_name || !record_id || !organisation_id || !supabase) return;
+    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();
@@ -1766,210 +2060,14 @@ 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/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/useEventTheme.ts
 import { useEffect as useEffect6 } from "react";
 import { useLocation } from "react-router-dom";
@@ -2059,54 +2157,9 @@ function usePreventTabReload(options = {}) {
   }, [enabled, gracePeriodMs]);
 }
 
-// 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"
-    }), []);
-  }
-}
-
 export {
   useDebounce,
+  cleanupQueryCache,
   useQueryCache,
   queryCacheHelpers,
   useAddressAutocomplete,
@@ -2137,13 +2190,7 @@ export {
   clearFileDisplayCache,
   getFileDisplayCacheStats,
   invalidateFileDisplayCache,
-  ErrorBoundary,
-  PublicPageContext,
-  PublicPageProvider,
-  usePublicPageContext,
-  useIsPublicPage,
   useEventTheme,
-  usePreventTabReload,
-  useAppConfig
+  usePreventTabReload
 };
-//# sourceMappingURL=chunk-UCQSRW7Z.js.map
+//# sourceMappingURL=chunk-NIU6J6OX.js.map