@jmruthers/pace-core 0.5.88 → 0.5.90

package/docs/api/modules.md

@@ -1,6 +1,6 @@
-[@jmruthers/pace-core - v0.5.88](README.md) / Exports
+[@jmruthers/pace-core - v0.5.90](README.md) / Exports
 
-# @jmruthers/pace-core - v0.5.88
+# @jmruthers/pace-core - v0.5.90
 
 **`File`**
 
@@ -3800,7 +3800,7 @@ Useful for testing or when you need to force refresh all data
 
 #### Defined in
 
-[packages/core/src/hooks/public/usePublicEvent.ts:412](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/hooks/public/usePublicEvent.ts#L412)
+[packages/core/src/hooks/public/usePublicEvent.ts:410](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/hooks/public/usePublicEvent.ts#L410)
 
 ___
 
@@ -3821,7 +3821,7 @@ Get cache statistics for debugging
 
 #### Defined in
 
-[packages/core/src/hooks/public/usePublicEvent.ts:423](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/hooks/public/usePublicEvent.ts#L423)
+[packages/core/src/hooks/public/usePublicEvent.ts:421](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/hooks/public/usePublicEvent.ts#L421)
 
 ___
 
@@ -6988,7 +6988,7 @@ Signed URL with expiration timestamp, or null if failed
 
 #### Defined in
 
-[packages/core/src/utils/storage/helpers.ts:234](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/utils/storage/helpers.ts#L234)
+[packages/core/src/utils/storage/helpers.ts:309](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/utils/storage/helpers.ts#L309)
 
 ___
 
@@ -7014,7 +7014,7 @@ Success status and optional error message
 
 #### Defined in
 
-[packages/core/src/utils/storage/helpers.ts:269](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/utils/storage/helpers.ts#L269)
+[packages/core/src/utils/storage/helpers.ts:344](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/utils/storage/helpers.ts#L344)
 
 ___
 
@@ -7039,7 +7039,7 @@ List of files with metadata
 
 #### Defined in
 
-[packages/core/src/utils/storage/helpers.ts:303](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/utils/storage/helpers.ts#L303)
+[packages/core/src/utils/storage/helpers.ts:378](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/utils/storage/helpers.ts#L378)
 
 ___
 
@@ -7065,7 +7065,7 @@ File blob with metadata, or null if failed
 
 #### Defined in
 
-[packages/core/src/utils/storage/helpers.ts:363](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/utils/storage/helpers.ts#L363)
+[packages/core/src/utils/storage/helpers.ts:438](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/utils/storage/helpers.ts#L438)
 
 ___
 
@@ -7092,4 +7092,4 @@ Move a file to archived location (soft delete)
 
 #### Defined in
 
-[packages/core/src/utils/storage/helpers.ts:416](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/utils/storage/helpers.ts#L416)
+[packages/core/src/utils/storage/helpers.ts:491](https://github.com/jmruthers/pace-core/blob/main/packages/core/src/utils/storage/helpers.ts#L491)

package/docs/implementation-guides/public-pages-advanced.md

@@ -407,6 +407,16 @@ interface LogoSize {
 
 #### Usage Examples
 
+> **Storage path formats**
+>
+> When configuring `event_logo` for an event, Pace supports multiple formats:
+>
+> - A fully qualified `https://` URL will be used directly.
+> - A storage path like `public-files/org-123/logo.png` automatically resolves against the standard buckets configured via `pace-core`.
+> - If your deployment stores logos in a different bucket, prefix the path with the bucket name using `custombucket/org-123/logo.png` (alphanumeric names) or `custom-bucket::org-123/logo.png` (bucket names containing hyphens).
+>
+> The double colon form helps when your folders start with numbers (for example `2024/`), ensuring they are not mistaken for bucket names.
+
 **Basic Logo Loading:**
 ```tsx
 import { usePublicEventLogo } from '@jmruthers/pace-core';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmruthers/pace-core",
-  "version": "0.5.88",
+  "version": "0.5.90",
   "description": "Clean, modern React component library with Tailwind v4 styling and native utilities",
   "private": false,
   "publishConfig": {

package/src/components/PaceLoginPage/PaceLoginPage.test.tsx

@@ -174,6 +174,16 @@ describe('PaceLoginPage Component', () => {
       expect(errorElement).toHaveClass('mt-4', 'text-destructive', 'text-center');
       expect(errorElement.tagName).toBe('EM');
     });
+
+    it('does not show benign AuthSessionMissingError on login page', () => {
+      const authErr = new Error('Auth session missing!');
+      authErr.name = 'AuthSessionMissingError';
+      mockAuthContext.authError = authErr as any;
+
+      renderWithProviders(<PaceLoginPage appName="Test App" />);
+
+      expect(screen.queryByText(/Auth session missing/i)).toBeNull();
+    });
   });
 
   // Role-based redirection tests

package/src/components/PaceLoginPage/PaceLoginPage.tsx

@@ -292,15 +292,18 @@ export const PaceLoginPage: React.FC<PaceLoginPageProps> = ({
     try {
       const { error } = await signIn(data.email, data.password);
 
-      if (!error) {
-        // Navigation will be handled by the useEffect that checks app access
-        // Don't navigate here if requireAppAccess is true
-        if (!requireAppAccess) {
-          try {
-            navigate(onSuccessRedirectPath, { replace: true });
-          } catch (navError) {
-            console.error('Navigation error after sign-in:', navError);
-          }
+      if (error) {
+        // Throw error so LoginForm can catch and display it
+        throw error;
+      }
+
+      // Navigation will be handled by the useEffect that checks app access
+      // Don't navigate here if requireAppAccess is true
+      if (!requireAppAccess) {
+        try {
+          navigate(onSuccessRedirectPath, { replace: true });
+        } catch (navError) {
+          console.error('Navigation error after sign-in:', navError);
         }
       }
     } finally {
@@ -325,11 +328,14 @@ export const PaceLoginPage: React.FC<PaceLoginPageProps> = ({
             console.error('Login error:', error);
           }}
         />
-        {authError && (
-          <em className="mt-4 text-destructive text-center">
-            {authError.message}
-          </em>
-        )}
+        {(() => {
+          const benign = !!(authError && (
+            authError.name === 'AuthSessionMissingError' || /Auth session missing/i.test(authError.message)
+          ));
+          return authError && !benign ? (
+            <em className="mt-4 text-destructive text-center">{authError.message}</em>
+          ) : null;
+        })()}
         {accessError && (
           <em className="mt-4 text-destructive text-center">
             {accessError}

package/src/hooks/public/usePublicEvent.ts

@@ -224,7 +224,6 @@ export function usePublicEvent(
                 event_catering_email,
                 event_news,
                 event_billing,
-                event_footer,
                 event_email
               `)
               .eq('event_code', eventCode)
@@ -301,7 +300,6 @@ export function usePublicEvent(
             event_catering_email,
             event_news,
             event_billing,
-            event_footer,
             event_email
           `)
           .eq('event_code', eventCode)

package/src/services/AuthService.ts

@@ -453,42 +453,42 @@ export class AuthService extends BaseService implements IAuthService {
         // Record error but continue to attempt getUser to satisfy edge cases
         console.debug('[AuthService] getSession returned error, attempting to fetch user anyway');
         this.authError = sessionError;
+        
+        // Attempt getUser as fallback when getSession fails
+        try {
+          const getUserFn = (this.supabaseClient.auth as any)?.getUser as (() => Promise<{ data?: { user?: User | null }, error?: AuthError | null }>) | undefined;
+          if (typeof getUserFn === 'function') {
+            const userResult = await getUserFn();
+            const currentUser = userResult?.data?.user ?? null;
+            const userError = userResult?.error ?? null;
+            
+            if (currentUser) {
+              this.user = currentUser;
+              // If we got a user but no session, we still don't have a valid session
+              this.session = null;
+            }
+            if (userError && !this.authError) {
+              this.authError = userError;
+            }
+          }
+        } catch (getUserError) {
+          // If getUser also fails, we've already recorded the sessionError
+          console.debug('[AuthService] getUser also failed:', getUserError);
+        }
       }
 
       if (currentSession) {
         this.session = currentSession;
         this.user = currentSession.user;
         this.authError = null;
-      } else {
-        console.debug('[AuthService] No active session found, checking for existing user');
+      } else if (!sessionError) {
+        // Only skip getUser if we didn't already attempt it due to a sessionError
+        // Treat missing session as a normal cold-start state on public pages (e.g., login)
+        // Do not call getUser() which can raise AuthSessionMissingError and surface a noisy banner
+        console.debug('[AuthService] No active session found; treating as normal unauthenticated state');
         this.session = null;
-        // Safely call getUser without destructuring
-        let currentUser: User | null = null;
-        let userError: AuthError | null = null;
-        const getUserFn = (this.supabaseClient.auth as any)?.getUser as (() => Promise<{ data?: { user?: User | null }, error?: AuthError | null }>) | undefined;
-        if (typeof getUserFn === 'function') {
-          const userResult = await getUserFn();
-          currentUser = userResult?.data?.user ?? null;
-          userError = userResult?.error ?? null;
-        }
-
-        if (userError) {
-          console.debug('[AuthService] getUser returned error during restoration');
-          this.authError = userError;
-        }
-
-        if (currentUser) {
-          this.user = currentUser;
-          console.debug('[AuthService] Found user without active session during restoration');
-        } else {
-          this.user = null;
-          this.session = null;
-        }
-
-        // Only clear authError if we successfully got user or had no errors
-        if (!userError && !sessionError) {
-          this.authError = null;
-        }
+        this.user = null;
+        this.authError = null;
       }
 
       // Finish successfully even if earlier calls reported an error, to avoid noisy warnings in benign cases

package/src/services/EventService.ts

@@ -14,6 +14,7 @@ import { IEventService } from './interfaces/IEventService';
 import { Event } from '../types/unified';
 import { Organisation } from '../types/organisation';
 import { DebugLogger } from '../utils/debugLogger';
+import { applyPalette, clearPalette } from '../theming/runtime';
 
 export class EventService extends BaseService implements IEventService {
   private events: Event[] = [];
@@ -135,6 +136,8 @@ export class EventService extends BaseService implements IEventService {
       this.persistEventSelection(event.event_id);
       // Reset the user cleared flag when selecting an event
       this.userClearedEventRef = false;
+      // Apply theme for the newly selected event
+      this.updateThemeForSelectedEvent();
     } else {
       this.selectedEvent = null;
       this.setSelectedEventId?.(null);
@@ -145,6 +148,8 @@ export class EventService extends BaseService implements IEventService {
       this.hasAutoSelectedRef = false;
       // Mark that user explicitly cleared the event to prevent auto-selection
       this.userClearedEventRef = true;
+      // Clear theme when event is cleared
+      this.updateThemeForSelectedEvent();
     }
     this.notify();
   }
@@ -175,6 +180,8 @@ export class EventService extends BaseService implements IEventService {
       if (persistedEvent) {
         this.selectedEvent = persistedEvent;
         this.setSelectedEventId?.(persistedEventId);
+        // Apply theme for persisted event
+        this.updateThemeForSelectedEvent();
         return true;
       } else {
         // Clear invalid persisted event
@@ -218,6 +225,8 @@ export class EventService extends BaseService implements IEventService {
       this.selectedEvent = nextEvent;
       this.setSelectedEventId?.(nextEvent.event_id);
       this.persistEventSelection(nextEvent.event_id);
+      // Apply theme for auto-selected event
+      this.updateThemeForSelectedEvent();
     }
   }
 
@@ -338,6 +347,62 @@ export class EventService extends BaseService implements IEventService {
     }
   }
 
+  /**
+   * Parse and normalize event_colours to PaletteData (supports ev-* keys and string JSON)
+   */
+  private parseAndNormalizeEventColours(input: unknown): { main: any; sec: any; acc: any } | null {
+    try {
+      if (!input) return null;
+      let obj: any = input;
+      if (typeof input === 'string') {
+        try {
+          obj = JSON.parse(input);
+        } catch {
+          return null;
+        }
+      } else if (typeof input !== 'object') {
+        return null;
+      }
+
+      const pick = (o: any, pref: string, plain: string) => (o?.[pref] ?? o?.[plain]) || null;
+      const main = pick(obj, 'ev-main', 'main');
+      const sec  = pick(obj, 'ev-sec',  'sec');
+      const acc  = pick(obj, 'ev-acc',  'acc');
+      if (!main && !sec && !acc) return null;
+
+      // Fill helper: ensure all TW shades exist using raw or 500 as fallback
+      const shades = ['50','100','200','300','400','500','600','700','800','900','950'];
+      const fill = (p: any) => {
+        if (!p) return {} as any;
+        const out: any = {};
+        for (const s of shades) out[s] = p[s] || p?.raw || p?.['500'];
+        if (p?.raw) out.raw = p.raw;
+        return out;
+      };
+
+      return { main: fill(main), sec: fill(sec), acc: fill(acc) };
+    } catch (error) {
+      console.warn('[EventService] Failed to parse/normalize event colours:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Apply or clear runtime theme variables based on the current selected event's colours
+   */
+  private updateThemeForSelectedEvent(): void {
+    try {
+      const normalized = this.parseAndNormalizeEventColours(this.selectedEvent?.event_colours);
+      if (normalized) {
+        applyPalette(normalized);
+      } else {
+        clearPalette();
+      }
+    } catch (error) {
+      console.warn('[EventService] Failed to update theme from event colours:', error);
+    }
+  }
+
   getNextEventByDate(events?: Event[]): Event | null {
     const eventsToUse = events || this.events;
     if (!eventsToUse || eventsToUse.length === 0) {

package/src/services/__tests__/AuthService.restoreSession.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect, vi } from 'vitest';
+import { AuthService } from '../../services/AuthService';
+
+// Minimal Supabase auth mock sufficient for restoreSession/initialize paths
+function createSupabaseMock() {
+  const auth = {
+    getSession: vi.fn().mockResolvedValue({ data: { session: null }, error: null }),
+    getUser: vi.fn(), // should not be called when session is null
+    onAuthStateChange: vi.fn().mockImplementation((cb: any) => {
+      // Provide a subscription-like object
+      return { unsubscribe: () => {} } as any;
+    }),
+  } as any;
+
+  return { auth } as any;
+}
+
+describe('AuthService.restoreSession (no session startup)', () => {
+  it('does not call getUser() and does not set authError when session is null', async () => {
+    const supabase = createSupabaseMock();
+    const service = new AuthService(supabase);
+
+    // initialize() triggers setup listener and restoreSession()
+    await service.initialize();
+
+    // Assertions
+    expect(supabase.auth.getSession).toHaveBeenCalledTimes(1);
+    expect(supabase.auth.getUser).not.toHaveBeenCalled();
+    expect(service.getError()).toBeNull();
+    expect(service.getUser()).toBeNull();
+    expect(service.getSession()).toBeNull();
+  });
+});
+
+

package/src/services/__tests__/AuthService.test.ts

@@ -518,23 +518,22 @@ describe('AuthService', () => {
       expect(mockSupabase.auth.getUser).toHaveBeenCalled();
     });
 
-    it('should handle initialization with getUser error', async () => {
-      const userError = new AuthError('User error');
+    it('should not call getUser when getSession succeeds with no session (prevents AuthSessionMissingError)', async () => {
       mockSupabase.auth.getSession.mockResolvedValue({
         data: { session: null },
         error: null
       });
-      mockSupabase.auth.getUser.mockResolvedValue({
-        data: { user: null },
-        error: userError
-      });
       mockSupabase.auth.onAuthStateChange.mockReturnValue({
         data: { subscription: { unsubscribe: vi.fn() } }
       });
 
       await authService.initialize();
 
-      expect(mockSupabase.auth.getUser).toHaveBeenCalled();
+      // When getSession succeeds with no session, getUser is NOT called to prevent
+      // AuthSessionMissingError from being raised on public pages (e.g., login page)
+      // This is intentional behavior to avoid noisy error banners for benign unauthenticated states
+      expect(mockSupabase.auth.getSession).toHaveBeenCalled();
+      expect(mockSupabase.auth.getUser).not.toHaveBeenCalled();
     });
 
     it('should restore session from storage during initialization', async () => {

package/src/services/__tests__/EventService.eventColours.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi } from 'vitest';
+import { EventService } from '../../services/EventService';
+
+function createSupabaseMock() {
+  const auth = {
+    onAuthStateChange: vi.fn().mockReturnValue({ unsubscribe: () => {} }),
+  } as any;
+  return { auth } as any;
+}
+
+const baseEvent = {
+  event_id: 'e1',
+  event_name: 'Test',
+  organisation_id: 'org1',
+};
+
+describe('EventService event_colours normalization', () => {
+  it('applies palettes when event_colours uses ev-* keys (object)', async () => {
+    const supabase = createSupabaseMock();
+    const svc = new EventService(supabase, null, null, 'APP', { id: 'org1' } as any, () => {});
+    // @ts-ignore access private for test by casting
+    (svc as any).selectedEvent = {
+      ...baseEvent,
+      event_colours: {
+        'ev-main': { raw: { L: 0.75, C: 0.1, H: 200 }, '500': { L: 0.75, C: 0.1, H: 200 } },
+        'ev-sec':  { raw: { L: 0.7, C: 0.12, H: 260 }, '500': { L: 0.7, C: 0.12, H: 260 } },
+        'ev-acc':  { raw: { L: 0.65, C: 0.14, H: 20 },  '500': { L: 0.65, C: 0.14, H: 20 } },
+      },
+    };
+
+    // Spy on document style updates by calling the method and ensuring no throw
+    expect(() => (svc as any).updateThemeForSelectedEvent()).not.toThrow();
+  });
+
+  it('parses string JSON with ev-* keys', () => {
+    const supabase = createSupabaseMock();
+    const svc = new EventService(supabase, null, null, 'APP', { id: 'org1' } as any, () => {});
+    const payload = JSON.stringify({
+      'ev-main': { '500': { L: 0.75, C: 0.1, H: 200 }, raw: { L: 0.75, C: 0.1, H: 200 } },
+      'ev-sec':  { '500': { L: 0.7, C: 0.12, H: 260 }, raw: { L: 0.7, C: 0.12, H: 260 } },
+      'ev-acc':  { '500': { L: 0.65, C: 0.14, H: 20 }, raw: { L: 0.65, C: 0.14, H: 20 } },
+    });
+    // @ts-ignore private
+    (svc as any).selectedEvent = { ...baseEvent, event_colours: payload };
+    expect(() => (svc as any).updateThemeForSelectedEvent()).not.toThrow();
+  });
+
+  it('accepts plain main/sec/acc', () => {
+    const supabase = createSupabaseMock();
+    const svc = new EventService(supabase, null, null, 'APP', { id: 'org1' } as any, () => {});
+    // @ts-ignore private
+    (svc as any).selectedEvent = {
+      ...baseEvent,
+      event_colours: {
+        main: { '500': { L: 0.75, C: 0.1, H: 200 } },
+        sec:  { '500': { L: 0.7, C: 0.12, H: 260 } },
+        acc:  { '500': { L: 0.65, C: 0.14, H: 20 } },
+      },
+    };
+    expect(() => (svc as any).updateThemeForSelectedEvent()).not.toThrow();
+  });
+
+  it('clears when invalid structure', () => {
+    const supabase = createSupabaseMock();
+    const svc = new EventService(supabase, null, null, 'APP', { id: 'org1' } as any, () => {});
+    // @ts-ignore private
+    (svc as any).selectedEvent = { ...baseEvent, event_colours: { something: {} } };
+    expect(() => (svc as any).updateThemeForSelectedEvent()).not.toThrow();
+  });
+});
+
+

package/src/utils/storage/helpers.test.ts

@@ -354,7 +354,7 @@ describe('[utility] Storage Helpers', () => {
   describe('getPublicUrl', () => {
     it('generates public URL for public bucket', () => {
       const filePath = 'org-123/logos/logo.png';
-      
+
       const mockGetPublicUrl = vi.fn().mockReturnValue({
         data: { publicUrl: 'https://example.com/public/logo.png' }
       });
@@ -370,9 +370,23 @@ describe('[utility] Storage Helpers', () => {
       expect(result).toBe('https://example.com/public/logo.png');
     });
 
+    it('returns direct URLs without calling storage', () => {
+      const directUrl = 'https://cdn.example.com/logo.png';
+
+      const localSupabase = createMockSupabaseClient();
+      localSupabase.storage = {
+        from: vi.fn()
+      };
+
+      const result = getPublicUrl(localSupabase as any, directUrl, true);
+
+      expect(localSupabase.storage.from).not.toHaveBeenCalled();
+      expect(result).toBe(directUrl);
+    });
+
     it('generates public URL for private bucket', () => {
       const filePath = 'org-123/documents/test.pdf';
-      
+
       const mockGetPublicUrl = vi.fn().mockReturnValue({
         data: { publicUrl: 'https://example.com/files/test.pdf' }
       });
@@ -387,10 +401,100 @@ describe('[utility] Storage Helpers', () => {
       expect(result).toBe('https://example.com/files/test.pdf');
     });
 
+    it('uses explicit bucket prefix when provided', () => {
+      const filePath = 'public-files/org-123/logo.png';
+
+      const mockGetPublicUrl = vi.fn().mockReturnValue({
+        data: { publicUrl: 'https://example.com/public/logo.png' }
+      });
+
+      mockSupabase.storage = {
+        from: vi.fn(() => ({ getPublicUrl: mockGetPublicUrl }))
+      };
+
+      const result = getPublicUrl(mockSupabase, filePath, true);
+
+      expect(mockSupabase.storage.from).toHaveBeenCalledWith('public-files');
+      expect(mockGetPublicUrl).toHaveBeenCalledWith('org-123/logo.png');
+      expect(result).toBe('https://example.com/public/logo.png');
+    });
+
+    it('supports custom bucket hints without hyphen characters', () => {
+      const filePath = 'branding/org-123/logo.png';
+
+      const mockGetPublicUrl = vi.fn().mockReturnValue({
+        data: { publicUrl: 'https://example.com/branding/logo.png' }
+      });
+
+      mockSupabase.storage = {
+        from: vi.fn(() => ({ getPublicUrl: mockGetPublicUrl }))
+      };
+
+      const result = getPublicUrl(mockSupabase, filePath, true);
+
+      expect(mockSupabase.storage.from).toHaveBeenCalledWith('branding');
+      expect(mockGetPublicUrl).toHaveBeenCalledWith('org-123/logo.png');
+      expect(result).toBe('https://example.com/branding/logo.png');
+    });
+
+    it('supports double colon bucket hints to avoid path ambiguity', () => {
+      const filePath = 'brand-assets::org-123/logo.png';
+
+      const mockGetPublicUrl = vi.fn().mockReturnValue({
+        data: { publicUrl: 'https://example.com/brand/logo.png' }
+      });
+
+      mockSupabase.storage = {
+        from: vi.fn(() => ({ getPublicUrl: mockGetPublicUrl }))
+      };
+
+      const result = getPublicUrl(mockSupabase, filePath, true);
+
+      expect(mockSupabase.storage.from).toHaveBeenCalledWith('brand-assets');
+      expect(mockGetPublicUrl).toHaveBeenCalledWith('org-123/logo.png');
+      expect(result).toBe('https://example.com/brand/logo.png');
+    });
+
+    it('treats numeric leading path segments as directories rather than buckets', () => {
+      const filePath = '2024/05/logo.png';
+
+      const mockGetPublicUrl = vi.fn().mockReturnValue({
+        data: { publicUrl: 'https://example.com/public/logo.png' }
+      });
+
+      mockSupabase.storage = {
+        from: vi.fn(() => ({ getPublicUrl: mockGetPublicUrl }))
+      };
+
+      const result = getPublicUrl(mockSupabase, filePath, true);
+
+      expect(mockSupabase.storage.from).toHaveBeenCalledWith('public-files');
+      expect(mockGetPublicUrl).toHaveBeenCalledWith(filePath);
+      expect(result).toBe('https://example.com/public/logo.png');
+    });
+
+    it('ignores bucket prefix when path starts with UUID', () => {
+      const filePath = '123e4567-e89b-12d3-a456-426614174000/event_logos/logo.png';
+
+      const mockGetPublicUrl = vi.fn().mockReturnValue({
+        data: { publicUrl: 'https://example.com/public/logo.png' }
+      });
+
+      mockSupabase.storage = {
+        from: vi.fn(() => ({ getPublicUrl: mockGetPublicUrl }))
+      };
+
+      const result = getPublicUrl(mockSupabase, filePath, true);
+
+      expect(mockSupabase.storage.from).toHaveBeenCalledWith('public-files');
+      expect(mockGetPublicUrl).toHaveBeenCalledWith(filePath);
+      expect(result).toBe('https://example.com/public/logo.png');
+    });
+
     it('validates required parameters', () => {
       expect(() => getPublicUrl(null as any, 'path', false))
         .toThrow();
-      
+
       expect(() => getPublicUrl(mockSupabase, '', false))
         .toThrow();
     });