@jmruthers/pace-core 0.6.9 → 0.6.11

package/dist/chunk-MPBLMWVR.js

@@ -1,2161 +0,0 @@
-import { clearPalette, parseAndNormalizeEventColours, applyPalette } from './chunk-5W2A3DRC.js';
-import { EventServiceContext } from './chunk-T5CVK4R3.js';
-import { assertAppId } from './chunk-4SXLQIZO.js';
-import { fetchPlaceDetails, createAddressFromPlaceResult, getAddressByPlaceId, fetchPlaceAutocomplete, setOrganisationContext } from './chunk-FYHN4DD5.js';
-import { createLogger, logger } from './chunk-TTRFSOKR.js';
-import { useState, useEffect, useCallback, useRef, useMemo, useContext } from 'react';
-import { useLocation } from 'react-router-dom';
-
-function useDebounce(value, delay) {
-  const [debouncedValue, setDebouncedValue] = useState(value);
-  useEffect(() => {
-    const handler = setTimeout(() => {
-      setDebouncedValue(value);
-    }, delay);
-    return () => {
-      clearTimeout(handler);
-    };
-  }, [value, delay]);
-  return debouncedValue;
-}
-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);
-  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 = {}) => {
-    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 core_person queries by user_id
-   * TTL: 5 minutes
-   */
-  pacePersonByUserId: (supabase, userId, fetchFn) => {
-    const cacheKey = `core_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 core_member queries by person_id
-   * TTL: 5 minutes
-   */
-  paceMemberByPersonId: (supabase, personId, fetchFn) => {
-    const cacheKey = `core_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;
-  }
-};
-function useAddressAutocomplete(apiKey, inputValue, options = {}) {
-  const {
-    debounceDelay = 300,
-    cacheEnabled = true,
-    cacheTTL = {
-      autocomplete: 3600,
-      // 1 hour
-      placeDetails: 86400
-      // 24 hours
-    },
-    autocompleteOptions
-  } = options;
-  const [suggestions, setSuggestions] = useState([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const debouncedInput = useDebounce(inputValue, debounceDelay);
-  const { getCachedQuery } = useQueryCache();
-  const abortControllerRef = useRef(null);
-  const memoizedAutocompleteOptions = useMemo(
-    () => autocompleteOptions,
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [JSON.stringify(autocompleteOptions)]
-  );
-  useEffect(() => {
-    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 = useCallback(
-    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 = useCallback(
-    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 = useCallback(() => {
-    setSuggestions([]);
-    setError(null);
-  }, []);
-  return {
-    suggestions,
-    isLoading,
-    error,
-    selectAddress,
-    getAddressByPlaceId: getAddressByPlaceIdFn,
-    clearSuggestions
-  };
-}
-
-// src/utils/storage/config.ts
-var FILE_SIZE_LIMITS = {
-  // Images
-  "image/jpeg": 5 * 1024 * 1024,
-  // 5MB
-  "image/png": 5 * 1024 * 1024,
-  // 5MB
-  "image/gif": 10 * 1024 * 1024,
-  // 10MB (for animations)
-  "image/webp": 5 * 1024 * 1024,
-  // 5MB
-  "image/svg+xml": 1 * 1024 * 1024,
-  // 1MB (vector graphics)
-  // Documents
-  "application/pdf": 50 * 1024 * 1024,
-  // 50MB
-  "application/msword": 25 * 1024 * 1024,
-  // 25MB
-  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": 25 * 1024 * 1024,
-  // 25MB
-  "application/vnd.ms-excel": 25 * 1024 * 1024,
-  // 25MB
-  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": 25 * 1024 * 1024,
-  // 25MB
-  // Archives
-  "application/zip": 100 * 1024 * 1024,
-  // 100MB
-  "application/x-rar-compressed": 100 * 1024 * 1024,
-  // 100MB
-  // Text files
-  "text/plain": 1 * 1024 * 1024,
-  // 1MB
-  "text/csv": 10 * 1024 * 1024,
-  // 10MB
-  "application/json": 10 * 1024 * 1024
-  // 10MB
-};
-var DEFAULT_FILE_SIZE_LIMIT = 10 * 1024 * 1024;
-var APP_PATH_MAPPING = {
-  "PACE": "event_logos",
-  "TRAC": "trac_accommodation",
-  // Default category for TRAC files
-  "MEDI": "documents",
-  "CAKE": "documents"
-};
-var STORAGE_CONFIG = {
-  bucketName: "files",
-  fileSizeLimits: FILE_SIZE_LIMITS,
-  defaultFileSizeLimit: DEFAULT_FILE_SIZE_LIMIT
-};
-function getFileSizeLimit(mimeType) {
-  return STORAGE_CONFIG.fileSizeLimits[mimeType] || STORAGE_CONFIG.defaultFileSizeLimit;
-}
-function getBucketName(isPublic) {
-  return isPublic ? "public-files" : "files";
-}
-function validateFileSize(file) {
-  const limit = getFileSizeLimit(file.type);
-  if (file.size > limit) {
-    const limitMB = Math.round(limit / (1024 * 1024));
-    const fileMB = Math.round(file.size / (1024 * 1024));
-    return {
-      isValid: false,
-      error: `File size (${fileMB}MB) exceeds limit (${limitMB}MB) for ${file.type}`
-    };
-  }
-  return { isValid: true };
-}
-
-// src/utils/storage/helpers.ts
-var log2 = createLogger("StorageHelpers");
-function generateFilePath(options, fileName) {
-  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 `${basePath}/${customPath}/${fileName}`;
-    }
-    return `${basePath}/public/${fileName}`;
-  }
-  if (customPath) {
-    return `${basePath}/${customPath}/${fileName}`;
-  }
-  const pathFolder = customPath || "files";
-  return `${basePath}/${pathFolder}/${fileName}`;
-}
-function generateUniqueFileName(originalName) {
-  const timestamp = Date.now();
-  const uuid = crypto.randomUUID();
-  const extension = originalName.split(".").pop() || "";
-  let baseName = originalName.replace(/\.[^/.]+$/, "");
-  baseName = baseName.trim().replace(/\s+/g, "_").replace(/[<>:"/\\|?*]/g, "").replace(/\.\./g, "").replace(/^\.+|\.+$/g, "").substring(0, 200);
-  if (!extension || extension === originalName) {
-    return `${timestamp}-${uuid}-${baseName}`;
-  }
-  return `${timestamp}-${uuid}-${baseName}.${extension}`;
-}
-async function extractFileMetadata(file, options, uploadedBy) {
-  const metadata = {
-    mimeType: file.type,
-    size: file.size,
-    ...options.orgId && { orgId: options.orgId },
-    ...options.userId && { userId: options.userId },
-    appName: options.appName || "pace-core",
-    uploadedBy,
-    uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    tags: options.tags || [],
-    isPublic: options.isPublic || false,
-    customMetadata: options.metadata || {}
-  };
-  if (file.type.startsWith("image/")) {
-    try {
-      const dimensions = await getImageDimensions(file);
-      metadata.width = dimensions.width;
-      metadata.height = dimensions.height;
-    } catch (_error) {
-    }
-  }
-  try {
-    metadata.hash = await generateFileHash(file);
-  } catch (_error) {
-  }
-  return metadata;
-}
-async function getImageDimensions(file) {
-  return new Promise((resolve, reject) => {
-    const img = new Image();
-    const url = URL.createObjectURL(file);
-    img.onload = () => {
-      URL.revokeObjectURL(url);
-      resolve({ width: img.width, height: img.height });
-    };
-    img.onerror = () => {
-      URL.revokeObjectURL(url);
-      reject(new Error("Could not load image"));
-    };
-    img.src = url;
-  });
-}
-async function generateFileHash(file) {
-  const buffer = await file.arrayBuffer();
-  const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  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) {
-      log2.debug(`Could not create folder placeholder (will be created on upload): ${uploadError.message}`);
-      return true;
-    }
-    return true;
-  } catch (error) {
-    log2.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);
-    if (!sizeValidation.isValid) {
-      return {
-        success: false,
-        error: sizeValidation.error
-      };
-    }
-    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,
-      contentType: file.type
-    });
-    if (error) {
-      return {
-        success: false,
-        error: `Upload failed: ${error.message}`
-      };
-    }
-    let publicUrl;
-    if (options.isPublic) {
-      const { data: urlData } = supabase.storage.from(bucketName).getPublicUrl(filePath);
-      publicUrl = urlData.publicUrl;
-    }
-    return {
-      success: true,
-      path: filePath,
-      publicUrl,
-      metadata
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Upload failed: ${error instanceof Error ? error.message : "Unknown error"}`
-    };
-  }
-}
-function getPublicUrl(supabase, path, isPublic = true) {
-  if (!supabase) {
-    throw new Error("Supabase client is required to generate a public URL");
-  }
-  if (!path || typeof path !== "string") {
-    throw new Error("A valid storage path is required to generate a public URL");
-  }
-  if (/^https?:\/\//i.test(path)) {
-    return path;
-  }
-  const normalisedPath = path.trim().replace(/^\/+/, "");
-  if (!normalisedPath) {
-    throw new Error("Storage path cannot be empty after normalisation");
-  }
-  const { bucketNameFromPath, storagePath } = resolveBucketHint(normalisedPath);
-  const bucketName = bucketNameFromPath || getBucketName(isPublic);
-  const { data } = supabase.storage.from(bucketName).getPublicUrl(storagePath);
-  return data.publicUrl;
-}
-function resolveBucketHint(pathWithPotentialBucket) {
-  const BUCKET_NAME_PATTERN = /^[a-z0-9][a-z0-9-_\.]{1,62}$/i;
-  const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-  const KNOWN_BUCKET_NAMES = /* @__PURE__ */ new Set(["files", "public-files"]);
-  const trimmedPath = pathWithPotentialBucket.trim();
-  if (!trimmedPath) {
-    throw new Error("Storage path cannot be empty after normalisation");
-  }
-  const doubleColonIndex = trimmedPath.indexOf("::");
-  if (doubleColonIndex > 0) {
-    const potentialBucket = trimmedPath.slice(0, doubleColonIndex).trim();
-    const remainingPath = trimmedPath.slice(doubleColonIndex + 2).replace(/^\/+/, "");
-    if (potentialBucket && remainingPath && BUCKET_NAME_PATTERN.test(potentialBucket)) {
-      return {
-        bucketNameFromPath: potentialBucket,
-        storagePath: remainingPath
-      };
-    }
-  }
-  const firstSlashIndex = trimmedPath.indexOf("/");
-  if (firstSlashIndex > 0) {
-    const potentialBucket = trimmedPath.slice(0, firstSlashIndex).trim();
-    const remainingPath = trimmedPath.slice(firstSlashIndex + 1).replace(/^\/+/, "");
-    if (potentialBucket && remainingPath && BUCKET_NAME_PATTERN.test(potentialBucket) && !UUID_PATTERN.test(potentialBucket) && (KNOWN_BUCKET_NAMES.has(potentialBucket) || !potentialBucket.includes("-")) && !/^\d+$/.test(potentialBucket)) {
-      return {
-        bucketNameFromPath: potentialBucket,
-        storagePath: remainingPath
-      };
-    }
-  }
-  return {
-    bucketNameFromPath: null,
-    storagePath: trimmedPath
-  };
-}
-async function getSignedUrl(supabase, path, options) {
-  try {
-    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);
-      return null;
-    }
-    return {
-      url: data.signedUrl,
-      expiresAt: new Date(Date.now() + (options.expiresIn || 3600) * 1e3).toISOString()
-    };
-  } catch (error) {
-    log2.error("Failed to create signed URL:", error);
-    return null;
-  }
-}
-var globalUrlCache = /* @__PURE__ */ new Map();
-var MAX_CACHE_SIZE = 500;
-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) {
-      log2.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) {
-        log2.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);
-    const { error } = await supabase.storage.from(bucketName).remove([path]);
-    if (error) {
-      return {
-        success: false,
-        error: `Delete failed: ${error.message}`
-      };
-    }
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Delete failed: ${error instanceof Error ? error.message : "Unknown error"}`
-    };
-  }
-}
-async function listFiles(supabase, options) {
-  try {
-    const bucketName = getBucketName(options.isPublic || false);
-    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,
-      offset: options.offset || 0,
-      sortBy: { column: "created_at", order: "desc" }
-    });
-    if (error) {
-      log2.error("Failed to list files:", error);
-      return { files: [], totalCount: 0, hasMore: false };
-    }
-    const files = (data || []).map((item) => ({
-      name: item.name,
-      path: `${searchPath}${item.name}`,
-      size: item.metadata?.size || 0,
-      mimeType: item.metadata?.mimetype || "application/octet-stream",
-      lastModified: item.updated_at || item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
-      metadata: {
-        mimeType: item.metadata?.mimetype || "application/octet-stream",
-        size: item.metadata?.size || 0,
-        ...options.orgId && { orgId: options.orgId },
-        ...options.userId && { userId: options.userId },
-        appName: options.appName,
-        uploadedBy: "unknown",
-        uploadedAt: item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
-        isPublic: options.isPublic || false
-      }
-    }));
-    return {
-      files,
-      totalCount: files.length,
-      hasMore: files.length >= (options.limit || 100)
-    };
-  } catch (error) {
-    log2.error("Failed to list files:", error);
-    return { files: [], totalCount: 0, hasMore: false };
-  }
-}
-async function downloadFile(supabase, path, isPublic = false) {
-  try {
-    const bucketName = getBucketName(isPublic);
-    const { data, error } = await supabase.storage.from(bucketName).download(path);
-    if (error) {
-      log2.error("Failed to download file:", error);
-      return null;
-    }
-    if (!data) {
-      return null;
-    }
-    const fileName = path.split("/").pop() || "download";
-    const { data: fileInfo } = await supabase.storage.from(bucketName).list(path.split("/").slice(0, -1).join("/"), {
-      search: fileName
-    });
-    const metadata = fileInfo?.[0]?.metadata || {};
-    return {
-      blob: data,
-      metadata: {
-        name: fileName,
-        size: metadata.size || data.size,
-        type: metadata.mimetype || "application/octet-stream"
-      }
-    };
-  } catch (error) {
-    log2.error("Failed to download file:", error);
-    return null;
-  }
-}
-async function archiveFile(supabase, path, options) {
-  try {
-    const bucketName = getBucketName(options.isPublic || false);
-    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 {
-        success: false,
-        error: `Archive failed: ${copyError.message}`
-      };
-    }
-    const deleteResult = await deleteFile(supabase, path, options.isPublic || false);
-    if (!deleteResult.success) {
-      return deleteResult;
-    }
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Archive failed: ${error instanceof Error ? error.message : "Unknown error"}`
-    };
-  }
-}
-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] = 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 () => {
-    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 });
-      }
-    }
-    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;
-      }
-    }
-    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("core_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("core_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 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]);
-  useEffect(() => {
-    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 = useCallback(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/utils/file-reference/index.ts
-var log3 = createLogger("FileReferenceService");
-var FileReferenceServiceImpl = class {
-  constructor(supabase) {
-    this.supabase = supabase;
-  }
-  /**
-   * Helper method to get app name from app ID
-   */
-  async getAppName(appId) {
-    try {
-      const { data, error } = await this.supabase.from("rbac_apps").select("name").eq("id", appId).single();
-      if (error || !data) {
-        return "unknown";
-      }
-      return data.name || "unknown";
-    } catch {
-      return "unknown";
-    }
-  }
-  /**
-   * 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 });
-      }
-      let isSuperAdminUser = false;
-      const userIdForCheck = authenticatedUserId || options.userId;
-      if (userIdForCheck) {
-        try {
-          const { isSuperAdmin } = await import('./api-7P7DI652.js');
-          isSuperAdminUser = await isSuperAdmin(userIdForCheck);
-          if (isSuperAdminUser) {
-            log3.debug("Super admin detected - bypassing permission checks", { userId: userIdForCheck });
-          }
-        } catch (superAdminCheckError) {
-          log3.warn("Failed to check super-admin status, proceeding with normal permission checks", superAdminCheckError);
-        }
-      }
-      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}`);
-      }
-      if (!uploadResult.path) {
-        throw new Error("File upload did not return a path");
-      }
-      const filePath = uploadResult.path;
-      const metadata = await extractFileMetadata(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
-      }, "system");
-      if (!isUserScoped && options.organisation_id) {
-        await setOrganisationContext(this.supabase, options.organisation_id);
-      }
-      let rpcUserId = null;
-      if (authenticatedUserId) {
-        rpcUserId = authenticatedUserId;
-      } else if (options.userId) {
-        rpcUserId = options.userId;
-      } else {
-        const { data: { user: authUser } } = await this.supabase.auth.getUser();
-        if (authUser) {
-          rpcUserId = authUser.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 ?? null,
-        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,
-          fileSize: file.size,
-          category: options.category,
-          ...metadata,
-          ...options.custom_metadata
-        },
-        p_is_public: options.is_public || false,
-        p_user_id: rpcUserId
-        // Always pass authenticated user ID for SECURITY DEFINER functions
-      });
-      if (error) {
-        await deleteFile(this.supabase, filePath, options.is_public || false);
-        throw new Error(`Failed to create file reference: ${error.message}`);
-      }
-      if (!data || data === null) {
-        await deleteFile(this.supabase, filePath, options.is_public || false);
-        const appName = await this.getAppName(options.app_id).catch(() => "unknown");
-        const pageContextDisplay = options.pageContext || "undefined";
-        if (isSuperAdminUser) {
-          throw new Error(
-            `File upload failed for super-admin user. This may indicate a database issue. Page context: '${pageContextDisplay}', App: '${appName}'. Please check that the page '${pageContextDisplay}' exists in rbac_app_pages table for app '${appName}'.`
-          );
-        } else {
-          throw new Error(
-            `File upload denied: insufficient permissions. You need 'create:page.${pageContextDisplay}' or 'update:page.${pageContextDisplay}' permission for the '${pageContextDisplay}' page. Make sure the page exists in rbac_app_pages table for app '${appName}'.`
-          );
-        }
-      }
-      const { data: fileRef, error: fetchError } = await this.supabase.from("core_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(
-        options.table_name,
-        options.record_id,
-        options.organisation_id || null,
-        options.category
-      );
-      return fileRef;
-    } catch (error) {
-      log3.error("Error creating file reference:", error);
-      throw error;
-    }
-  }
-  async getFileReference(table_name, record_id, organisation_id) {
-    try {
-      let query = this.supabase.from("core_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;
-        }
-        throw new Error(`Failed to get file reference: ${error.message}`);
-      }
-      return data;
-    } catch (error) {
-      log3.error("Error getting file reference:", error);
-      throw error;
-    }
-  }
-  async getFileUrl(table_name, record_id, organisation_id) {
-    try {
-      const fileRef = await this.getFileReference(table_name, record_id, organisation_id);
-      if (!fileRef) {
-        return null;
-      }
-      if (fileRef.is_public) {
-        const { data: pathData } = await this.supabase.rpc("data_file_reference_url_get", {
-          p_table_name: table_name,
-          p_record_id: record_id,
-          p_organisation_id: organisation_id
-        });
-        if (!pathData) {
-          return null;
-        }
-        return getPublicUrl(this.supabase, pathData, true);
-      } else {
-        return await this.getSignedUrl(table_name, record_id, organisation_id);
-      }
-    } catch (error) {
-      log3.error("Error getting file URL:", error);
-      throw error;
-    }
-  }
-  async getSignedUrl(table_name, record_id, organisation_id, expires_in = 3600) {
-    try {
-      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 ?? null,
-        p_expires_in: expires_in
-      });
-      if (error) {
-        throw new Error(`Failed to get signed URL: ${error.message}`);
-      }
-      if (!filePath) {
-        return null;
-      }
-      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) {
-      log3.error("Error getting signed URL:", error);
-      throw error;
-    }
-  }
-  async updateFileReference(id, updates) {
-    try {
-      const { data, error } = await this.supabase.from("core_file_references").update(updates).eq("id", id).select().single();
-      if (error) {
-        throw new Error(`Failed to update file reference: ${error.message}`);
-      }
-      return data;
-    } catch (error) {
-      log3.error("Error updating file reference:", error);
-      throw error;
-    }
-  }
-  async deleteFileReference(table_name, record_id, organisation_id, delete_file = false) {
-    try {
-      const fileRef = await this.getFileReference(table_name, record_id, organisation_id);
-      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 ?? null,
-        p_delete_file: delete_file
-      });
-      if (error) {
-        throw new Error(`Failed to delete file reference: ${error.message}`);
-      }
-      if (delete_file && fileRef) {
-        await deleteFile(this.supabase, fileRef.file_path, fileRef.is_public || false);
-      }
-      return true;
-    } catch (error) {
-      log3.error("Error deleting file reference:", error);
-      throw error;
-    }
-  }
-  async listFileReferences(table_name, record_id, organisation_id) {
-    try {
-      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 ?? null
-      });
-      if (error) {
-        throw new Error(`Failed to list file references: ${error.message}`);
-      }
-      if (!data || data.length === 0) {
-        return [];
-      }
-      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: 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,
-          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);
-      throw error;
-    }
-  }
-  async getFileCount(table_name, record_id, organisation_id) {
-    try {
-      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 ?? null
-      });
-      if (error) {
-        throw new Error(`Failed to get file count: ${error.message}`);
-      }
-      return data || 0;
-    } catch (error) {
-      log3.error("Error getting file count:", error);
-      throw error;
-    }
-  }
-  async getFileReferenceById(id, organisation_id) {
-    try {
-      const { data, error } = await this.supabase.rpc("data_file_reference_get", {
-        p_file_reference_id: id,
-        p_organisation_id: organisation_id ?? null
-      });
-      if (error) {
-        throw new Error(`Failed to get file reference by ID: ${error.message}`);
-      }
-      if (!data || data.length === 0) {
-        return null;
-      }
-      return data[0];
-    } catch (error) {
-      log3.error("Error getting file reference by ID:", error);
-      throw error;
-    }
-  }
-  async getFilesByCategory(table_name, record_id, category, organisation_id) {
-    try {
-      const { data, error } = await this.supabase.rpc("data_file_reference_by_category_list", {
-        p_table_name: table_name,
-        p_record_id: record_id,
-        p_category: category,
-        p_organisation_id: organisation_id ?? null
-      });
-      if (error) {
-        log3.error("RPC ERROR getting files by category:", {
-          error,
-          errorCode: error.code,
-          errorMessage: error.message,
-          errorDetails: error.details,
-          table_name,
-          record_id,
-          category,
-          organisation_id,
-          message: "CRITICAL: Category filtering MUST use RPC function data_file_reference_by_category_list. Direct queries with .eq('category', ...) will FAIL with HTTP 406 because category is stored in file_metadata JSONB field, not a direct column."
-        });
-        throw new Error(`Failed to get files by category: ${error.message}. Category filtering uses file_metadata JSONB field, not a direct column. RPC function required.`);
-      }
-      if (!data || data.length === 0) {
-        return [];
-      }
-      const fileReferences = data.filter((item) => {
-        const fileCategory = item.file_metadata?.category;
-        const matches = fileCategory === category;
-        if (!matches) {
-          log3.warn("File category mismatch in RPC response:", {
-            fileId: item.id,
-            expectedCategory: category,
-            actualCategory: fileCategory
-          });
-        }
-        return matches && 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,
-            category: item.file_metadata?.category || "general_documents" /* GENERAL_DOCUMENTS */,
-            ...item.file_metadata || {}
-          },
-          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,
-          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 getting files by category:", error);
-      throw error;
-    }
-  }
-  async uploadMultipleFiles(options, files) {
-    const success = [];
-    const failed = [];
-    const results = [];
-    for (const file of files) {
-      try {
-        const fileReference = await this.createFileReference(options, file);
-        success.push(fileReference);
-        results.push({
-          file,
-          result: {
-            file_reference: fileReference,
-            file_url: fileReference.is_public ? getPublicUrl(this.supabase, fileReference.file_path, true) : ""
-          }
-        });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        failed.push({ file, error: message });
-        results.push({ file, result: null, error: message });
-      }
-    }
-    return {
-      success,
-      failed,
-      total: results.length,
-      successful: success.length,
-      results
-    };
-  }
-};
-function createFileReferenceService(supabase) {
-  return new FileReferenceServiceImpl(supabase);
-}
-async function uploadFileWithReference(supabase, options, file) {
-  const service = createFileReferenceService(supabase);
-  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 || void 0,
-    userId: options.userId || void 0,
-    expiresIn: 3600
-  });
-  const urlString = typeof fileUrl === "string" ? fileUrl : fileUrl?.url || "";
-  return {
-    file_reference: fileReference,
-    file_url: urlString,
-    signed_url: options.is_public ? void 0 : urlString || void 0
-  };
-}
-
-// src/hooks/useFileDisplay.ts
-var authenticatedFileCache = /* @__PURE__ */ new Map();
-var MAX_CACHE_SIZE2 = 100;
-function cleanupCache() {
-  const now = Date.now();
-  const entries = Array.from(authenticatedFileCache.entries());
-  const expiredKeys = [];
-  entries.forEach(([key, value]) => {
-    if (now - value.timestamp >= value.ttl) {
-      expiredKeys.push(key);
-    }
-  });
-  expiredKeys.forEach((key) => authenticatedFileCache.delete(key));
-  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_SIZE2);
-    toRemove.forEach(([key]) => authenticatedFileCache.delete(key));
-  }
-}
-function useFileDisplay(table_name, record_id, organisation_id, category, options) {
-  const {
-    cacheTtl = 30 * 60 * 1e3,
-    // 30 minutes
-    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 isMountedRef = useRef(true);
-  const safeSetState = (setter, value) => {
-    if (isMountedRef.current) {
-      setter(value);
-    }
-  };
-  const fetchFiles = useCallback(async () => {
-    if (!table_name || !record_id || !supabase) {
-      safeSetState(setFileUrl, null);
-      safeSetState(setFileReference, null);
-      safeSetState(setFileReferences, []);
-      safeSetState(setFileUrls, /* @__PURE__ */ new Map());
-      safeSetState(setFileCount, 0);
-      safeSetState(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("useFileDisplay", "Invalid organisationId format (not a valid UUID):", organisation_id);
-      }
-    }
-    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) {
-        const cachedData = cached.data;
-        if (cachedData.fileReference && !cachedData.fileUrl && cachedData.fileReference.is_public === false && supabase) {
-          try {
-            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;
-            safeSetState(setFileUrl, regeneratedUrl);
-            safeSetState(setFileReference, cachedData.fileReference);
-            safeSetState(setFileReferences, cachedData.fileReferences || []);
-            safeSetState(setFileUrls, cachedData.fileUrls || /* @__PURE__ */ new Map());
-            safeSetState(setFileCount, cachedData.fileCount || 0);
-            safeSetState(setIsLoading, false);
-            safeSetState(setError, null);
-            return;
-          } catch (err) {
-            logger.warn("useFileDisplay", "Failed to regenerate signed URL from cache, falling back to fetch:", err);
-          }
-        }
-        safeSetState(setFileUrl, cachedData.fileUrl || null);
-        safeSetState(setFileReference, cachedData.fileReference || null);
-        safeSetState(setFileReferences, cachedData.fileReferences || []);
-        safeSetState(setFileUrls, cachedData.fileUrls || /* @__PURE__ */ new Map());
-        safeSetState(setFileCount, cachedData.fileCount || 0);
-        safeSetState(setIsLoading, false);
-        safeSetState(setError, null);
-        return;
-      }
-    }
-    try {
-      safeSetState(setIsLoading, true);
-      safeSetState(setError, null);
-      const service = createFileReferenceService(supabase);
-      let files = [];
-      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("core_organisation_memberships").select("organisation_id").eq("user_id", user.id);
-            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("core_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;
-        });
-        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("core_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 {
-        if (category) {
-          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("core_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) {
-        safeSetState(setFileUrl, null);
-        safeSetState(setFileReference, null);
-        safeSetState(setFileReferences, []);
-        safeSetState(setFileUrls, /* @__PURE__ */ new Map());
-        safeSetState(setFileCount, 0);
-        if (enableCache) {
-          authenticatedFileCache.set(cacheKey, {
-            data: { fileUrl: null, fileReference: null, fileReferences: [], fileUrls: /* @__PURE__ */ new Map(), fileCount: 0 },
-            timestamp: Date.now(),
-            ttl: cacheTtl
-          });
-          cleanupCache();
-        }
-        return;
-      }
-      safeSetState(setFileReferences, files);
-      safeSetState(setFileCount, files.length);
-      if (category && files.length > 0) {
-        const firstFile = files[0];
-        safeSetState(setFileReference, firstFile);
-        let url = null;
-        if (firstFile.is_public) {
-          url = getPublicUrl(supabase, firstFile.file_path, true);
-        } else {
-          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;
-          if (!url) {
-            logger.warn("useFileDisplay", "Failed to generate signed URL for file:", {
-              file_path: firstFile.file_path,
-              record_id,
-              table_name
-            });
-          }
-        }
-        safeSetState(setFileUrl, url);
-      } else {
-        const urlMap = await generateFileUrlsBatch(supabase, files, {
-          appName: "pace-core",
-          orgId: organisation_id,
-          userId: organisation_id ? void 0 : record_id,
-          expiresIn: 3600
-        });
-        safeSetState(setFileUrls, urlMap);
-        safeSetState(setFileReference, null);
-        safeSetState(setFileUrl, null);
-      }
-      if (enableCache) {
-        let cacheData = {
-          fileReference: category && files.length > 0 ? files[0] : null,
-          fileReferences: files,
-          fileUrls: /* @__PURE__ */ new Map(),
-          fileCount: files.length
-        };
-        if (category && files.length > 0) {
-          const firstFile = files[0];
-          let url = null;
-          if (firstFile.is_public) {
-            url = getPublicUrl(supabase, firstFile.file_path, true);
-          }
-          cacheData.fileUrl = url;
-        } else {
-          const urlMap = /* @__PURE__ */ new Map();
-          for (const fileRef of files) {
-            if (fileRef.is_public) {
-              const url = getPublicUrl(supabase, fileRef.file_path, true);
-              if (url) {
-                urlMap.set(fileRef.id, url);
-              }
-            }
-          }
-          cacheData.fileUrls = urlMap;
-        }
-        authenticatedFileCache.set(cacheKey, {
-          data: cacheData,
-          timestamp: Date.now(),
-          ttl: cacheTtl
-        });
-        cleanupCache();
-      }
-    } catch (err) {
-      logger.error("useFileDisplay", "Error fetching files:", err);
-      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
-      safeSetState(setError, error2);
-      safeSetState(setFileUrl, null);
-      safeSetState(setFileReference, null);
-      safeSetState(setFileReferences, []);
-      safeSetState(setFileUrls, /* @__PURE__ */ new Map());
-      safeSetState(setFileCount, 0);
-    } finally {
-      safeSetState(setIsLoading, false);
-    }
-  }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
-  useEffect(() => {
-    isMountedRef.current = true;
-    if (table_name && record_id && supabase) {
-      fetchFiles().catch((err) => {
-        if (isMountedRef.current) {
-          safeSetState(setError, err instanceof Error ? err : new Error("Unknown error"));
-        }
-      });
-    } else {
-      safeSetState(setFileUrl, null);
-      safeSetState(setFileReference, null);
-      safeSetState(setFileReferences, []);
-      safeSetState(setFileUrls, /* @__PURE__ */ new Map());
-      safeSetState(setFileCount, 0);
-      safeSetState(setIsLoading, false);
-      safeSetState(setError, null);
-    }
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, [table_name, record_id, organisation_id, supabase]);
-  const refetch = useCallback(async () => {
-    if (!table_name || !record_id || !supabase) return;
-    if (enableCache) {
-      const cacheKey = `file_${table_name}_${record_id}_${organisation_id === void 0 ? "undefined" : organisation_id ?? "null"}_${category || "all"}`;
-      authenticatedFileCache.delete(cacheKey);
-    }
-    await fetchFiles();
-  }, [fetchFiles, table_name, record_id, organisation_id, category, supabase, enableCache]);
-  return {
-    fileUrl,
-    fileReference,
-    fileReferences,
-    fileUrls,
-    fileCount,
-    isLoading,
-    error,
-    refetch
-  };
-}
-function clearFileDisplayCache() {
-  for (const [key] of authenticatedFileCache) {
-    if (key.startsWith("file_")) {
-      authenticatedFileCache.delete(key);
-    }
-  }
-}
-function getFileDisplayCacheStats() {
-  const keys = Array.from(authenticatedFileCache.keys()).filter((key) => key.startsWith("file_"));
-  return {
-    size: keys.length,
-    keys
-  };
-}
-function invalidateFileDisplayCache(table_name, record_id, organisation_id, category) {
-  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 === void 0 ? "undefined" : organisation_id ?? "null"}_all`;
-    authenticatedFileCache.delete(allCategoryKey);
-  }
-}
-var log4 = createLogger("useEventTheme");
-function useEventTheme(event) {
-  const location = useLocation();
-  const eventServiceContext = useContext(EventServiceContext);
-  const eventsContextSelectedEvent = eventServiceContext?.eventService?.getSelectedEvent() ?? null;
-  const selectedEvent = event !== void 0 ? event : eventsContextSelectedEvent;
-  useEffect(() => {
-    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) {
-      log4.error("Failed to apply event palette:", error);
-    }
-    return () => {
-    };
-  }, [selectedEvent, location.pathname]);
-}
-function usePreventTabReload(options = {}) {
-  const { enabled = true, gracePeriodMs = 2e3 } = options;
-  const isRestoringFromCacheRef = useRef(false);
-  const gracePeriodTimeoutRef = useRef(null);
-  useEffect(() => {
-    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]);
-}
-
-export { APP_PATH_MAPPING, DEFAULT_FILE_SIZE_LIMIT, FILE_SIZE_LIMITS, STORAGE_CONFIG, archiveFile, cleanupQueryCache, clearFileDisplayCache, clearPublicFileDisplayCache, createFileReferenceService, deleteFile, downloadFile, extractFileMetadata, generateFilePath, generateFileUrlsBatch, generateUniqueFileName, getBucketName, getFileDisplayCacheStats, getFileSizeLimit, getPublicFileDisplayCacheStats, getPublicUrl, getSignedUrl, invalidateFileDisplayCache, listFiles, queryCacheHelpers, uploadFile, uploadFileWithReference, useAddressAutocomplete, useDebounce, useEventTheme, useFileDisplay, usePreventTabReload, usePublicFileDisplay, useQueryCache, validateFileSize };