@jmruthers/pace-core 0.5.185 → 0.5.187

package/dist/{chunk-MX3EIJGQ.js → chunk-C4OYJOV4.js}

@@ -1,15 +1,19 @@
 import {
   useEvents
-} from "./chunk-XAUHJD3L.js";
+} from "./chunk-K2JGDXGU.js";
 import {
   useUnifiedAuth
-} from "./chunk-FXFJRTKI.js";
+} from "./chunk-WK2Y6TGA.js";
 import {
   assertAppId
 } from "./chunk-QXHPKYJV.js";
 import {
+  createAddressFromPlaceResult,
+  fetchPlaceAutocomplete,
+  fetchPlaceDetails,
+  getAddressByPlaceId,
   performanceBudgetMonitor
-} from "./chunk-FMUCXFII.js";
+} from "./chunk-YHCN776L.js";
 import {
   setOrganisationContext
 } from "./chunk-VBXEHIUJ.js";
@@ -23,10 +27,354 @@ import {
   logger
 } from "./chunk-PWLANIRT.js";
 
+// src/hooks/useDebounce.ts
+import { useState, useEffect } from "react";
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+
+// src/hooks/useQueryCache.ts
+import { useCallback } from "react";
+var log = createLogger("useQueryCache");
+var queryCache = /* @__PURE__ */ new Map();
+var CLEANUP_INTERVAL_MS = 5 * 60 * 1e3;
+var cleanupTimer = null;
+function runCacheCleanup() {
+  const now = Date.now();
+  const expiredKeys = [];
+  queryCache.forEach((entry, key) => {
+    if (entry.expiresAt <= now) {
+      expiredKeys.push(key);
+    }
+  });
+  expiredKeys.forEach((key) => {
+    queryCache.delete(key);
+    log.debug(`Removed expired query from cache: ${key}`);
+  });
+}
+if (typeof window !== "undefined" && !cleanupTimer) {
+  cleanupTimer = setInterval(runCacheCleanup, CLEANUP_INTERVAL_MS);
+  log.debug("Query cache cleanup initialized.");
+}
+function useQueryCache(supabase) {
+  const getCachedQuery = useCallback(async (table, filterKey, filterValue, fetchFn, options = {}) => {
+    const { ttl = 300, enabled = true } = options;
+    const cacheKey = `${table}:${filterKey}:${filterValue}`;
+    const now = Date.now();
+    if (!enabled) {
+      return fetchFn();
+    }
+    const cached = queryCache.get(cacheKey);
+    if (cached) {
+      if (cached.expiresAt > now && cached.data !== void 0) {
+        log.debug(`Cache hit for query: ${cacheKey}`);
+        return cached.data;
+      }
+      if (cached.promise) {
+        log.debug(`Waiting for in-flight request: ${cacheKey}`);
+        return cached.promise;
+      }
+    }
+    log.debug(`Cache miss for query: ${cacheKey}, fetching...`);
+    const fetchPromise = fetchFn();
+    queryCache.set(cacheKey, {
+      data: void 0,
+      expiresAt: now + ttl * 1e3,
+      promise: fetchPromise
+    });
+    try {
+      const data = await fetchPromise;
+      queryCache.set(cacheKey, {
+        data,
+        expiresAt: now + ttl * 1e3
+      });
+      log.debug(`Cached query result: ${cacheKey}, expires in ${ttl}s`);
+      return data;
+    } catch (error) {
+      queryCache.delete(cacheKey);
+      log.error(`Query failed for ${cacheKey}:`, error);
+      throw error;
+    }
+  }, []);
+  const invalidateQuery = useCallback((table, filterKey, filterValue) => {
+    const cacheKey = `${table}:${filterKey}:${filterValue}`;
+    queryCache.delete(cacheKey);
+    log.debug(`Invalidated query cache: ${cacheKey}`);
+  }, []);
+  const clearCache = useCallback(() => {
+    queryCache.clear();
+    log.debug("Cleared all query cache entries.");
+  }, []);
+  const getCacheStats = useCallback(() => {
+    return {
+      size: queryCache.size,
+      keys: Array.from(queryCache.keys())
+    };
+  }, []);
+  return {
+    getCachedQuery,
+    invalidateQuery,
+    clearCache,
+    getCacheStats
+  };
+}
+var queryCacheHelpers = {
+  /**
+   * Cache pace_person queries by user_id
+   * TTL: 5 minutes
+   */
+  pacePersonByUserId: (supabase, userId, fetchFn) => {
+    const cacheKey = `pace_person:user_id:${userId}`;
+    const now = Date.now();
+    const ttl = 300 * 1e3;
+    const cached = queryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now && cached.data !== void 0) {
+      return Promise.resolve(cached.data);
+    }
+    if (cached?.promise) {
+      return cached.promise;
+    }
+    const promise = fetchFn();
+    queryCache.set(cacheKey, {
+      data: void 0,
+      expiresAt: now + ttl,
+      promise
+    });
+    promise.then((data) => {
+      queryCache.set(cacheKey, { data, expiresAt: now + ttl });
+    }).catch(() => {
+      queryCache.delete(cacheKey);
+    });
+    return promise;
+  },
+  /**
+   * Cache pace_member queries by person_id
+   * TTL: 5 minutes
+   */
+  paceMemberByPersonId: (supabase, personId, fetchFn) => {
+    const cacheKey = `pace_member:person_id:${personId}`;
+    const now = Date.now();
+    const ttl = 300 * 1e3;
+    const cached = queryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now && cached.data !== void 0) {
+      return Promise.resolve(cached.data);
+    }
+    if (cached?.promise) {
+      return cached.promise;
+    }
+    const promise = fetchFn();
+    queryCache.set(cacheKey, {
+      data: void 0,
+      expiresAt: now + ttl,
+      promise
+    });
+    promise.then((data) => {
+      queryCache.set(cacheKey, { data, expiresAt: now + ttl });
+    }).catch(() => {
+      queryCache.delete(cacheKey);
+    });
+    return promise;
+  },
+  /**
+   * Cache rbac_app_pages queries by app_id
+   * TTL: 15 minutes (app pages are relatively static)
+   */
+  rbacAppPagesByAppId: (supabase, appId, fetchFn) => {
+    const cacheKey = `rbac_app_pages:app_id:${appId}`;
+    const now = Date.now();
+    const ttl = 15 * 60 * 1e3;
+    const cached = queryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now && cached.data !== void 0) {
+      return Promise.resolve(cached.data);
+    }
+    if (cached?.promise) {
+      return cached.promise;
+    }
+    const promise = fetchFn();
+    queryCache.set(cacheKey, {
+      data: void 0,
+      expiresAt: now + ttl,
+      promise
+    });
+    promise.then((data) => {
+      queryCache.set(cacheKey, { data, expiresAt: now + ttl });
+    }).catch(() => {
+      queryCache.delete(cacheKey);
+    });
+    return promise;
+  }
+};
+
+// src/hooks/useAddressAutocomplete.ts
+import { useState as useState2, useEffect as useEffect3, useCallback as useCallback2, useRef as useRef2, useMemo } from "react";
+function useAddressAutocomplete(apiKey, inputValue, options = {}) {
+  const {
+    debounceDelay = 300,
+    cacheEnabled = true,
+    cacheTTL = {
+      autocomplete: 3600,
+      // 1 hour
+      placeDetails: 86400
+      // 24 hours
+    },
+    autocompleteOptions
+  } = options;
+  const [suggestions, setSuggestions] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const debouncedInput = useDebounce(inputValue, debounceDelay);
+  const { getCachedQuery } = useQueryCache();
+  const abortControllerRef = useRef2(null);
+  const memoizedAutocompleteOptions = useMemo(
+    () => autocompleteOptions,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(autocompleteOptions)]
+  );
+  useEffect3(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    if (!debouncedInput.trim()) {
+      setSuggestions([]);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+    if (!apiKey) {
+      setError(new Error("Google Places API key is required"));
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    const fetchSuggestions = async () => {
+      try {
+        let predictions;
+        if (cacheEnabled) {
+          predictions = await getCachedQuery(
+            "google-places-autocomplete",
+            "query",
+            debouncedInput,
+            async () => {
+              return fetchPlaceAutocomplete(debouncedInput, apiKey, memoizedAutocompleteOptions);
+            },
+            { ttl: cacheTTL.autocomplete, enabled: true }
+          );
+        } else {
+          predictions = await fetchPlaceAutocomplete(debouncedInput, apiKey, memoizedAutocompleteOptions);
+        }
+        setSuggestions(predictions);
+        setIsLoading(false);
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          return;
+        }
+        const error2 = err instanceof Error ? err : new Error("Failed to fetch autocomplete suggestions");
+        setError(error2);
+        setSuggestions([]);
+        setIsLoading(false);
+      }
+    };
+    fetchSuggestions();
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+    };
+  }, [debouncedInput, apiKey, cacheEnabled, cacheTTL.autocomplete]);
+  const selectAddress = useCallback2(
+    async (placeId) => {
+      if (!placeId || !apiKey) {
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        let placeDetails;
+        if (cacheEnabled) {
+          placeDetails = await getCachedQuery(
+            "google-places-details",
+            "place_id",
+            placeId,
+            async () => {
+              return fetchPlaceDetails(placeId, apiKey);
+            },
+            { ttl: cacheTTL.placeDetails, enabled: true }
+          );
+        } else {
+          placeDetails = await fetchPlaceDetails(placeId, apiKey);
+        }
+        const parsedAddress = createAddressFromPlaceResult(placeDetails);
+        setIsLoading(false);
+        return parsedAddress;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Failed to fetch place details");
+        setError(error2);
+        setIsLoading(false);
+        return null;
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [apiKey, cacheEnabled, cacheTTL.placeDetails]
+  );
+  const getAddressByPlaceIdFn = useCallback2(
+    async (placeId) => {
+      if (!placeId || !apiKey) {
+        return null;
+      }
+      try {
+        if (cacheEnabled) {
+          return await getCachedQuery(
+            "google-places-details",
+            "place_id",
+            placeId,
+            async () => {
+              const result = await getAddressByPlaceId(placeId, apiKey);
+              if (!result) {
+                throw new Error("Failed to fetch address");
+              }
+              return result;
+            },
+            { ttl: cacheTTL.placeDetails, enabled: true }
+          );
+        } else {
+          return await getAddressByPlaceId(placeId, apiKey);
+        }
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Failed to get address by place_id");
+        setError(error2);
+        return null;
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [apiKey, cacheEnabled, cacheTTL.placeDetails]
+  );
+  const clearSuggestions = useCallback2(() => {
+    setSuggestions([]);
+    setError(null);
+  }, []);
+  return {
+    suggestions,
+    isLoading,
+    error,
+    selectAddress,
+    getAddressByPlaceId: getAddressByPlaceIdFn,
+    clearSuggestions
+  };
+}
+
 // src/hooks/useEventTheme.ts
-import { useEffect } from "react";
+import { useEffect as useEffect4 } from "react";
 import { useLocation } from "react-router-dom";
-var log = createLogger("useEventTheme");
+var log2 = createLogger("useEventTheme");
 function useEventTheme(event) {
   const location = useLocation();
   let selectedEvent;
@@ -44,7 +392,7 @@ function useEventTheme(event) {
       selectedEvent = null;
     }
   }
-  useEffect(() => {
+  useEffect4(() => {
     const isOnLoginRoute = location.pathname === "/login" || location.pathname.startsWith("/login");
     if (isOnLoginRoute) {
       clearPalette();
@@ -63,13 +411,55 @@ function useEventTheme(event) {
     try {
       applyPalette(normalized);
     } catch (error) {
-      log.error("Failed to apply event palette:", 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";
@@ -217,7 +607,7 @@ var ErrorBoundary = class extends Component {
 };
 
 // src/components/PublicLayout/PublicPageProvider.tsx
-import { createContext, useContext, useMemo } from "react";
+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);
@@ -234,7 +624,7 @@ function PublicPageProvider({ children, appName }) {
   };
   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 = useMemo(() => {
+  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;
@@ -267,7 +657,7 @@ function useIsPublicPage() {
 }
 
 // src/hooks/useAppConfig.ts
-import { useMemo as useMemo2, useContext as useContext2 } from "react";
+import { useMemo as useMemo3, useContext as useContext2 } from "react";
 function useAppConfig() {
   const isPublicPage = useIsPublicPage();
   const publicPageContext = useContext2(PublicPageContext);
@@ -285,7 +675,7 @@ function useAppConfig() {
       }
       return "PACE";
     };
-    return useMemo2(() => ({
+    return useMemo3(() => ({
       supportsDirectAccess: false,
       // Public pages don't support direct access
       requiresEvent: true,
@@ -296,14 +686,14 @@ function useAppConfig() {
   }
   try {
     const { appConfig, appName } = useUnifiedAuth();
-    return useMemo2(() => ({
+    return useMemo3(() => ({
       supportsDirectAccess: !(appConfig?.requires_event ?? true),
       requiresEvent: appConfig?.requires_event ?? true,
       isLoading: appConfig === null,
       appName
     }), [appConfig?.requires_event, appName]);
   } catch (error) {
-    return useMemo2(() => ({
+    return useMemo3(() => ({
       supportsDirectAccess: false,
       requiresEvent: true,
       isLoading: false,
@@ -382,7 +772,7 @@ function validateFileSize(file) {
 }
 
 // src/utils/storage/helpers.ts
-var log2 = createLogger("StorageHelpers");
+var log3 = createLogger("StorageHelpers");
 function generateFilePath(options, fileName) {
   const { orgId, isPublic = false, customPath } = options;
   if (!orgId) {
@@ -397,8 +787,8 @@ function generateFilePath(options, fileName) {
   if (customPath) {
     return `${orgId}/${customPath}/${fileName}`;
   }
-  const pathCategory = customPath || "files";
-  return `${orgId}/${pathCategory}/${fileName}`;
+  const pathFolder = customPath || "files";
+  return `${orgId}/${pathFolder}/${fileName}`;
 }
 function generateUniqueFileName(originalName) {
   const timestamp = Date.now();
@@ -459,6 +849,33 @@ async function generateFileHash(file) {
   const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
   return `sha256:${hashHex}`;
 }
+async function ensureFolderExists(supabase, folderPath, bucketName) {
+  try {
+    const { data, error } = await supabase.storage.from(bucketName).list(folderPath, {
+      limit: 1
+    });
+    if (!error) {
+      return true;
+    }
+    const placeholderPath = `${folderPath}/.keep`;
+    const placeholderBlob = new Blob([""], { type: "text/plain" });
+    const placeholderFile = new File([placeholderBlob], ".keep", { type: "text/plain" });
+    const { error: uploadError } = await supabase.storage.from(bucketName).upload(placeholderPath, placeholderFile, {
+      cacheControl: "3600",
+      upsert: true,
+      // Use upsert to avoid errors if file already exists
+      contentType: "text/plain"
+    });
+    if (uploadError) {
+      log3.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"}`);
+    return true;
+  }
+}
 async function uploadFile(supabase, file, options) {
   try {
     const sizeValidation = validateFileSize(file);
@@ -470,8 +887,10 @@ async function uploadFile(supabase, file, options) {
     }
     const uniqueFileName = generateUniqueFileName(file.name);
     const filePath = generateFilePath(options, uniqueFileName);
+    const folderPath = filePath.substring(0, filePath.lastIndexOf("/"));
     const metadata = await extractFileMetadata(file, options, "current-user");
     const bucketName = getBucketName(options.isPublic || false);
+    await ensureFolderExists(supabase, folderPath, bucketName);
     const { data, error } = await supabase.storage.from(bucketName).upload(filePath, file, {
       cacheControl: "3600",
       upsert: false,
@@ -560,7 +979,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) {
-      log2.error("Failed to create signed URL:", error);
+      log3.error("Failed to create signed URL:", error);
       return null;
     }
     return {
@@ -568,10 +987,105 @@ async function getSignedUrl(supabase, path, options) {
       expiresAt: new Date(Date.now() + (options.expiresIn || 3600) * 1e3).toISOString()
     };
   } catch (error) {
-    log2.error("Failed to create signed URL:", error);
+    log3.error("Failed to create signed URL:", error);
     return null;
   }
 }
+var globalUrlCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 500;
+var DEFAULT_TTL_MS = 3600 * 1e3;
+function getCacheKey(fileId, filePath, isPublic) {
+  return `file-url:${fileId}:${isPublic ? "public" : "private"}`;
+}
+function cleanupUrlCache() {
+  const now = Date.now();
+  for (const [key, value] of globalUrlCache.entries()) {
+    if (value.expiresAt < now) {
+      globalUrlCache.delete(key);
+    }
+  }
+  if (globalUrlCache.size > MAX_CACHE_SIZE) {
+    const entries = Array.from(globalUrlCache.entries());
+    entries.sort((a, b) => a[1].expiresAt - b[1].expiresAt);
+    const toRemove = Math.floor(MAX_CACHE_SIZE * 0.2);
+    for (let i = 0; i < toRemove && i < entries.length; i++) {
+      globalUrlCache.delete(entries[i][0]);
+    }
+  }
+}
+async function generateFileUrlsBatch(supabase, fileReferences, options) {
+  const urlMap = /* @__PURE__ */ new Map();
+  if (fileReferences.length === 0) {
+    return urlMap;
+  }
+  const now = Date.now();
+  const ttl = (options.expiresIn || 3600) * 1e3;
+  const publicFiles = [];
+  const privateFiles = [];
+  const uncachedFiles = [];
+  for (const fileRef of fileReferences) {
+    const cacheKey = getCacheKey(fileRef.id, fileRef.file_path, fileRef.is_public);
+    const cached = globalUrlCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+      urlMap.set(fileRef.id, cached.url);
+      continue;
+    }
+    if (fileRef.is_public) {
+      publicFiles.push({ id: fileRef.id, file_path: fileRef.file_path });
+    } else {
+      privateFiles.push({ id: fileRef.id, file_path: fileRef.file_path });
+    }
+    uncachedFiles.push(fileRef);
+  }
+  for (const file of publicFiles) {
+    try {
+      const url = getPublicUrl(supabase, file.file_path, true);
+      if (url) {
+        urlMap.set(file.id, url);
+        const cacheKey = getCacheKey(file.id, file.file_path, true);
+        globalUrlCache.set(cacheKey, {
+          url,
+          expiresAt: now + ttl
+        });
+      }
+    } catch (err) {
+      log3.error(`Failed to generate public URL for file ${file.id}:`, err);
+    }
+  }
+  if (privateFiles.length > 0) {
+    const signedUrlPromises = privateFiles.map(async (file) => {
+      try {
+        const signedUrlResult = await getSignedUrl(supabase, file.file_path, {
+          appName: options.appName || "pace-core",
+          orgId: options.orgId,
+          expiresIn: options.expiresIn || 3600
+        });
+        const url = signedUrlResult?.url || null;
+        if (url) {
+          const cacheKey = getCacheKey(file.id, file.file_path, false);
+          globalUrlCache.set(cacheKey, {
+            url,
+            expiresAt: now + ttl
+          });
+        }
+        return { id: file.id, url };
+      } catch (err) {
+        log3.error(`Failed to generate signed URL for file ${file.id}:`, err);
+        return { id: file.id, url: null };
+      }
+    });
+    const signedUrlResults = await Promise.all(signedUrlPromises);
+    for (const result of signedUrlResults) {
+      if (result.url) {
+        urlMap.set(result.id, result.url);
+      }
+    }
+  }
+  if (uncachedFiles.length > 0) {
+    cleanupUrlCache();
+  }
+  return urlMap;
+}
 async function deleteFile(supabase, path, isPublic = false) {
   try {
     const bucketName = getBucketName(isPublic);
@@ -601,7 +1115,7 @@ async function listFiles(supabase, options) {
       sortBy: { column: "created_at", order: "desc" }
     });
     if (error) {
-      log2.error("Failed to list files:", error);
+      log3.error("Failed to list files:", error);
       return { files: [], totalCount: 0, hasMore: false };
     }
     const files = (data || []).map((item) => ({
@@ -626,7 +1140,7 @@ async function listFiles(supabase, options) {
       hasMore: files.length >= (options.limit || 100)
     };
   } catch (error) {
-    log2.error("Failed to list files:", error);
+    log3.error("Failed to list files:", error);
     return { files: [], totalCount: 0, hasMore: false };
   }
 }
@@ -635,7 +1149,7 @@ async function downloadFile(supabase, path, isPublic = false) {
     const bucketName = getBucketName(isPublic);
     const { data, error } = await supabase.storage.from(bucketName).download(path);
     if (error) {
-      log2.error("Failed to download file:", error);
+      log3.error("Failed to download file:", error);
       return null;
     }
     if (!data) {
@@ -655,7 +1169,7 @@ async function downloadFile(supabase, path, isPublic = false) {
       }
     };
   } catch (error) {
-    log2.error("Failed to download file:", error);
+    log3.error("Failed to download file:", error);
     return null;
   }
 }
@@ -684,10 +1198,10 @@ async function archiveFile(supabase, path, options) {
 }
 
 // src/hooks/useFileDisplay.ts
-import { useState, useEffect as useEffect2, useCallback } from "react";
+import { useState as useState3, useEffect as useEffect6, useCallback as useCallback3 } from "react";
 
 // src/utils/file-reference/index.ts
-var log3 = createLogger("FileReferenceService");
+var log4 = createLogger("FileReferenceService");
 var FileReferenceServiceImpl = class {
   constructor(supabase) {
     this.supabase = supabase;
@@ -697,7 +1211,7 @@ var FileReferenceServiceImpl = class {
    * 
    * Storage Flow:
    * 1. Upload file to storage bucket first (files or public-files based on is_public flag)
-   *    - Path format: {orgId}/{category}/{timestamp-uuid-filename}
+   *    - 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
@@ -717,12 +1231,15 @@ var FileReferenceServiceImpl = class {
       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.");
+      }
       const uploadResult = await uploadFile(this.supabase, file, {
         appName: "file-reference",
         orgId: options.organisation_id,
         isPublic: options.is_public || false,
-        customPath: options.category
-        // Use category as the custom path segment
+        customPath: options.folder
+        // Use folder prop as the custom path segment
       });
       if (!uploadResult.success) {
         throw new Error(`Failed to upload file: ${uploadResult.error}`);
@@ -745,6 +1262,8 @@ var FileReferenceServiceImpl = class {
         p_organisation_id: options.organisation_id,
         p_app_id: options.app_id,
         p_page_context: options.pageContext,
+        p_event_id: options.event_id || null,
+        // Pass event_id for event-based apps
         p_file_metadata: {
           fileName: file.name,
           fileType: file.type,
@@ -759,8 +1278,13 @@ var FileReferenceServiceImpl = class {
         await deleteFile(this.supabase, filePath, options.is_public || false);
         throw new Error(`Failed to create file reference: ${error.message}`);
       }
-      const { data: fileRef, error: fetchError } = await this.supabase.from("file_references").select("*").eq("id", data).single();
+      if (!data || data === null) {
+        await deleteFile(this.supabase, filePath, options.is_public || false);
+        throw new Error(`File upload denied: insufficient permissions. You need 'create:page.${options.pageContext}' or 'update:page.${options.pageContext}' permission for the '${options.pageContext}' page. Make sure the page exists in rbac_app_pages table.`);
+      }
+      const { data: fileRef, error: fetchError } = 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("id", data).single();
       if (fetchError || !fileRef) {
+        await deleteFile(this.supabase, filePath, options.is_public || false);
         throw new Error(`Failed to fetch created file reference: ${fetchError?.message}`);
       }
       invalidateFileDisplayCache(
@@ -771,13 +1295,13 @@ var FileReferenceServiceImpl = class {
       );
       return fileRef;
     } catch (error) {
-      log3.error("Error creating file reference:", error);
+      log4.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("*").eq("table_name", table_name).eq("record_id", record_id).eq("organisation_id", organisation_id).single();
+      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();
       if (error) {
         if (error.code === "PGRST116") {
           return null;
@@ -786,7 +1310,7 @@ var FileReferenceServiceImpl = class {
       }
       return data;
     } catch (error) {
-      log3.error("Error getting file reference:", error);
+      log4.error("Error getting file reference:", error);
       throw error;
     }
   }
@@ -810,7 +1334,7 @@ var FileReferenceServiceImpl = class {
         return await this.getSignedUrl(table_name, record_id, organisation_id);
       }
     } catch (error) {
-      log3.error("Error getting file URL:", error);
+      log4.error("Error getting file URL:", error);
       throw error;
     }
   }
@@ -835,7 +1359,7 @@ var FileReferenceServiceImpl = class {
       });
       return signedUrlResult?.url || null;
     } catch (error) {
-      log3.error("Error getting signed URL:", error);
+      log4.error("Error getting signed URL:", error);
       throw error;
     }
   }
@@ -847,7 +1371,7 @@ var FileReferenceServiceImpl = class {
       }
       return data;
     } catch (error) {
-      log3.error("Error updating file reference:", error);
+      log4.error("Error updating file reference:", error);
       throw error;
     }
   }
@@ -868,7 +1392,7 @@ var FileReferenceServiceImpl = class {
       }
       return true;
     } catch (error) {
-      log3.error("Error deleting file reference:", error);
+      log4.error("Error deleting file reference:", error);
       throw error;
     }
   }
@@ -885,14 +1409,32 @@ var FileReferenceServiceImpl = class {
       if (!data || data.length === 0) {
         return [];
       }
-      const ids = data.map((item) => item.id);
-      const { data: fullData, error: fetchError } = await this.supabase.from("file_references").select("*").in("id", ids);
-      if (fetchError) {
-        throw new Error(`Failed to fetch file references: ${fetchError.message}`);
-      }
-      return fullData || [];
+      const fileReferences = data.filter((item) => item.id && item.file_path && item.file_metadata).map((item) => {
+        const fileName = item.file_path.split("/").pop() || "unknown";
+        const fileType = fileName.split(".").pop() || "unknown";
+        const fileRef = {
+          id: item.id,
+          table_name,
+          record_id,
+          file_path: item.file_path,
+          file_metadata: {
+            fileName,
+            fileType,
+            ...item.file_metadata || {}
+          },
+          organisation_id,
+          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,
+          created_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString()
+          // RPC doesn't return updated_at, use created_at
+        };
+        return fileRef;
+      });
+      return fileReferences;
     } catch (error) {
-      log3.error("Error listing file references:", error);
+      log4.error("Error listing file references:", error);
       throw error;
     }
   }
@@ -908,7 +1450,7 @@ var FileReferenceServiceImpl = class {
       }
       return data || 0;
     } catch (error) {
-      log3.error("Error getting file count:", error);
+      log4.error("Error getting file count:", error);
       throw error;
     }
   }
@@ -926,7 +1468,7 @@ var FileReferenceServiceImpl = class {
       }
       return data[0];
     } catch (error) {
-      log3.error("Error getting file reference by ID:", error);
+      log4.error("Error getting file reference by ID:", error);
       throw error;
     }
   }
@@ -939,7 +1481,7 @@ var FileReferenceServiceImpl = class {
         p_organisation_id: organisation_id
       });
       if (error) {
-        log3.error("RPC ERROR getting files by category:", {
+        log4.error("RPC ERROR getting files by category:", {
           error,
           errorCode: error.code,
           errorMessage: error.message,
@@ -959,7 +1501,7 @@ var FileReferenceServiceImpl = class {
         const fileCategory = item.file_metadata?.category;
         const matches = fileCategory === category;
         if (!matches) {
-          log3.warn("File category mismatch in RPC response:", {
+          log4.warn("File category mismatch in RPC response:", {
             fileId: item.id,
             expectedCategory: category,
             actualCategory: fileCategory
@@ -992,7 +1534,7 @@ var FileReferenceServiceImpl = class {
       });
       return fileReferences;
     } catch (error) {
-      log3.error("Error getting files by category:", error);
+      log4.error("Error getting files by category:", error);
       throw error;
     }
   }
@@ -1047,7 +1589,7 @@ async function uploadFileWithReference(supabase, options, file) {
 
 // src/hooks/useFileDisplay.ts
 var authenticatedFileCache = /* @__PURE__ */ new Map();
-var MAX_CACHE_SIZE = 100;
+var MAX_CACHE_SIZE2 = 100;
 function cleanupCache() {
   const now = Date.now();
   const entries = Array.from(authenticatedFileCache.entries());
@@ -1058,9 +1600,9 @@ function cleanupCache() {
     }
   });
   expiredKeys.forEach((key) => authenticatedFileCache.delete(key));
-  if (authenticatedFileCache.size > MAX_CACHE_SIZE) {
+  if (authenticatedFileCache.size > MAX_CACHE_SIZE2) {
     const sorted = entries.filter(([key]) => !expiredKeys.includes(key)).sort((a, b) => a[1].timestamp - b[1].timestamp);
-    const toRemove = sorted.slice(0, authenticatedFileCache.size - MAX_CACHE_SIZE);
+    const toRemove = sorted.slice(0, authenticatedFileCache.size - MAX_CACHE_SIZE2);
     toRemove.forEach(([key]) => authenticatedFileCache.delete(key));
   }
 }
@@ -1071,14 +1613,14 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
     enableCache = true,
     supabase
   } = options;
-  const [fileUrl, setFileUrl] = useState(null);
-  const [fileReference, setFileReference] = useState(null);
-  const [fileReferences, setFileReferences] = useState([]);
-  const [fileUrls, setFileUrls] = useState(/* @__PURE__ */ new Map());
-  const [fileCount, setFileCount] = useState(0);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const fetchFiles = useCallback(async () => {
+  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) {
       setFileUrl(null);
       setFileReference(null);
@@ -1196,23 +1738,11 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
         logger.debug("useFileDisplay", "Setting file URL:", url ? "URL set" : "URL is null");
         setFileUrl(url);
       } else {
-        const urlMap = /* @__PURE__ */ new Map();
-        for (const fileRef of files) {
-          let url = null;
-          if (fileRef.is_public) {
-            url = getPublicUrl(supabase, fileRef.file_path, true);
-          } else {
-            const signedUrlResult = await getSignedUrl(supabase, fileRef.file_path, {
-              appName: "pace-core",
-              orgId: organisation_id,
-              expiresIn: 3600
-            });
-            url = signedUrlResult?.url || null;
-          }
-          if (url) {
-            urlMap.set(fileRef.id, url);
-          }
-        }
+        const urlMap = await generateFileUrlsBatch(supabase, files, {
+          appName: "pace-core",
+          orgId: organisation_id,
+          expiresIn: 3600
+        });
         setFileUrls(urlMap);
         setFileReference(null);
         setFileUrl(null);
@@ -1263,7 +1793,7 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
       setIsLoading(false);
     }
   }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
-  useEffect2(() => {
+  useEffect6(() => {
     if (table_name && record_id && organisation_id && supabase) {
       fetchFiles();
     } else {
@@ -1276,7 +1806,7 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
       setError(null);
     }
   }, [fetchFiles, table_name, record_id, organisation_id, supabase]);
-  const refetch = useCallback(async () => {
+  const refetch = useCallback3(async () => {
     if (!table_name || !record_id || !organisation_id || !supabase) return;
     if (enableCache) {
       const cacheKey = `file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
@@ -1319,7 +1849,7 @@ function invalidateFileDisplayCache(table_name, record_id, organisation_id, cate
 }
 
 // src/hooks/public/usePublicFileDisplay.ts
-import { useState as useState2, useEffect as useEffect3, useCallback as useCallback2 } from "react";
+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 {
@@ -1328,14 +1858,14 @@ function usePublicFileDisplay(table_name, record_id, organisation_id, category,
     enableCache = true,
     supabase
   } = options;
-  const [fileUrl, setFileUrl] = useState2(null);
-  const [fileReference, setFileReference] = useState2(null);
-  const [fileReferences, setFileReferences] = useState2([]);
-  const [fileUrls, setFileUrls] = useState2(/* @__PURE__ */ new Map());
-  const [fileCount, setFileCount] = useState2(0);
-  const [isLoading, setIsLoading] = useState2(false);
-  const [error, setError] = useState2(null);
-  const fetchFiles = useCallback2(async () => {
+  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);
@@ -1434,7 +1964,7 @@ function usePublicFileDisplay(table_name, record_id, organisation_id, category,
           files = [];
         } else {
           const ids = fileIds.map((item) => item.id);
-          const { data: fullData, error: fetchError } = await supabase.from("file_references").select("*").in("id", ids).eq("is_public", true);
+          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");
           }
@@ -1477,13 +2007,11 @@ function usePublicFileDisplay(table_name, record_id, organisation_id, category,
         const url = getPublicUrl(supabase, firstFile.file_path, true);
         setFileUrl(url);
       } else {
-        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);
-          }
-        }
+        const urlMap = await generateFileUrlsBatch(supabase, fileRefs, {
+          appName: "pace-core",
+          orgId: organisation_id,
+          expiresIn: 3600
+        });
         setFileUrls(urlMap);
         setFileReference(null);
         setFileUrl(null);
@@ -1530,7 +2058,7 @@ function usePublicFileDisplay(table_name, record_id, organisation_id, category,
       setIsLoading(false);
     }
   }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
-  useEffect3(() => {
+  useEffect7(() => {
     if (table_name && record_id && organisation_id) {
       fetchFiles();
     } else {
@@ -1543,7 +2071,7 @@ function usePublicFileDisplay(table_name, record_id, organisation_id, category,
       setError(null);
     }
   }, [fetchFiles, table_name, record_id, organisation_id]);
-  const refetch = useCallback2(async () => {
+  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"}`;
@@ -1578,7 +2106,12 @@ function getPublicFileDisplayCacheStats() {
 }
 
 export {
+  useDebounce,
+  useQueryCache,
+  queryCacheHelpers,
+  useAddressAutocomplete,
   useEventTheme,
+  usePreventTabReload,
   ErrorBoundary,
   PublicPageContext,
   PublicPageProvider,
@@ -1598,6 +2131,7 @@ export {
   uploadFile,
   getPublicUrl,
   getSignedUrl,
+  generateFileUrlsBatch,
   deleteFile,
   listFiles,
   downloadFile,
@@ -1612,4 +2146,4 @@ export {
   clearPublicFileDisplayCache,
   getPublicFileDisplayCacheStats
 };
-//# sourceMappingURL=chunk-MX3EIJGQ.js.map
+//# sourceMappingURL=chunk-C4OYJOV4.js.map