@jmruthers/pace-core 0.5.181 → 0.5.183

package/src/hooks/__tests__/useRBAC.unit.test.ts

@@ -123,6 +123,8 @@ describe('useRBAC (unit)', () => {
       selectedEvent: null,
       eventLoading: false,
     });
+    mockResolveAppContext.mockResolvedValue({ appId: 'app-1' as any, hasAccess: true });
+    mockGetPermissionMap.mockResolvedValue({});
     mockGetRoleContext.mockResolvedValue({
       globalRole: null,
       organisationRole: null,
@@ -132,7 +134,15 @@ describe('useRBAC (unit)', () => {
 
     const { result } = renderHook(() => useRBAC());
 
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    await waitFor(() => {
+      expect(mockResolveAppContext).toHaveBeenCalled();
+      expect(mockGetAccessLevel).toHaveBeenCalled();
+    });
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.eventAppRole).toBe('planner');
+    });
 
     expect(result.current.eventAppRole).toBe('planner');
   });
@@ -175,6 +185,9 @@ describe('useRBAC (unit)', () => {
       selectedEvent: null,
       eventLoading: false,
     });
+    mockResolveAppContext.mockResolvedValue({ appId: 'app-1' as any, hasAccess: true });
+    mockGetPermissionMap.mockResolvedValue({});
+    mockGetAccessLevel.mockResolvedValue('viewer');
     mockGetRoleContext.mockResolvedValue({
       globalRole: null,
       organisationRole: 'org_admin',
@@ -183,8 +196,17 @@ describe('useRBAC (unit)', () => {
 
     const { result } = renderHook(() => useRBAC());
 
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    await waitFor(() => {
+      expect(mockResolveAppContext).toHaveBeenCalled();
+      expect(mockGetRoleContext).toHaveBeenCalled();
+    });
 
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.organisationRole).toBe('org_admin');
+    });
+
+    expect(result.current.organisationRole).toBe('org_admin');
     expect(result.current.hasGlobalPermission('org_admin')).toBe(true);
     expect(result.current.hasGlobalPermission('super_admin')).toBe(false);
   });

package/src/hooks/index.ts

@@ -55,6 +55,10 @@ export type { UseDataTablePerformanceOptions, UseDataTablePerformanceReturn } fr
 export { useFileDisplay, clearFileDisplayCache, getFileDisplayCacheStats, invalidateFileDisplayCache } from './useFileDisplay';
 export type { UseFileDisplayReturn, UseFileDisplayOptions } from './useFileDisplay';
 
+// === STORAGE HOOKS ===
+export { useStorage, useFileUpload } from './useStorage';
+export type { UseStorageOptions, UseStorageReturn } from './useStorage';
+
 // === PUBLIC DATA ACCESS HOOKS ===
 export * from './public';
 

package/src/hooks/public/index.ts

@@ -19,6 +19,7 @@
 // === PUBLIC DATA ACCESS HOOKS ===
 export { usePublicEvent, clearPublicEventCache, getPublicEventCacheStats } from './usePublicEvent';
 export { usePublicFileDisplay, clearPublicFileDisplayCache, getPublicFileDisplayCacheStats } from './usePublicFileDisplay';
+export { usePublicEventLogo, clearPublicLogoCache, getPublicLogoCacheStats } from './usePublicEventLogo';
 
 // === PUBLIC ROUTE HOOKS ===
 export { 
@@ -31,4 +32,5 @@ export {
 // === PUBLIC TYPES ===
 export type { UsePublicEventReturn, UsePublicEventOptions } from './usePublicEvent';
 export type { UsePublicFileDisplayReturn, UsePublicFileDisplayOptions } from './usePublicFileDisplay';
+export type { UsePublicEventLogoReturn, UsePublicEventLogoOptions } from './usePublicEventLogo';
 export type { UsePublicRouteParamsReturn } from './usePublicRouteParams';

package/src/hooks/public/usePublicEvent.ts

@@ -61,8 +61,9 @@
 
 import { useState, useEffect, useCallback, useMemo } from 'react';
 import { createClient } from '@supabase/supabase-js';
-import type { Event } from '../../types/unified';
+import type { Event } from '../../types/event';
 import type { Database } from '../../types/database';
+import { assertOrganisationId } from '../../types/core';
 import { usePublicPageContext } from '../../components/PublicLayout/PublicPageProvider';
 import { logger } from '../../utils/core/logger';
 
@@ -352,13 +353,10 @@ export function usePublicEvent(
         event_participants: eventData.event_participants,
         event_logo: eventData.event_logo,
         event_colours: eventData.event_colours,
-        organisation_id: eventData.organisation_id,
+        organisation_id: assertOrganisationId(eventData.organisation_id),
         is_visible: true,
         created_at: new Date().toISOString(),
-        updated_at: new Date().toISOString(),
-        // Legacy compatibility
-        name: eventData.event_name,
-        start_date: eventData.event_date
+        updated_at: new Date().toISOString()
       };
 
       setEvent(transformedEvent);

package/src/hooks/public/usePublicEventLogo.test.ts

@@ -0,0 +1,147 @@
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach, afterAll } from 'vitest';
+import {
+  usePublicEventLogo,
+  clearPublicLogoCache,
+  getPublicLogoCacheStats
+} from './usePublicEventLogo';
+import { createMockSupabaseClient } from '../../__tests__/helpers/supabaseMock';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { Database } from '../../types/database';
+
+vi.mock('../../utils/core/logger', () => {
+  const logger = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn()
+  };
+  return {
+    createLogger: vi.fn(() => logger)
+  };
+});
+
+const VALID_ORG_ID = '123e4567-e89b-12d3-a456-426614174000';
+const originalFetch = globalThis.fetch;
+
+describe('usePublicEventLogo', () => {
+  let mockSupabase: SupabaseClient<Database>;
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    mockSupabase = createMockSupabaseClient() as unknown as SupabaseClient<Database>;
+    fetchMock = vi.fn().mockResolvedValue({ ok: true });
+    (globalThis as any).fetch = fetchMock;
+    clearPublicLogoCache();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    clearPublicLogoCache();
+  });
+
+  afterAll(() => {
+    (globalThis as any).fetch = originalFetch;
+  });
+
+  it('fetches and caches the logo when RPC succeeds', async () => {
+    const logoUrl = 'https://cdn.example.com/logo.png';
+    (mockSupabase.rpc as any).mockResolvedValue({ data: [{ logo_url: logoUrl }], error: null });
+
+    const { result } = renderHook(() =>
+      usePublicEventLogo('event-123', 'Big Event', VALID_ORG_ID, {
+        supabase: mockSupabase
+      })
+    );
+
+    await waitFor(() => expect(result.current.logoUrl).toBe(logoUrl));
+    expect(result.current.fallbackText).toBe('BE');
+    expect(fetchMock).toHaveBeenCalledWith(logoUrl, { method: 'HEAD' });
+
+    const stats = getPublicLogoCacheStats();
+    expect(stats.size).toBe(1);
+    expect(stats.keys[0]).toContain('event-123');
+  });
+
+  it('refetch clears cache and requests fresh data', async () => {
+    const firstUrl = 'https://cdn.example.com/logo.png';
+    const secondUrl = 'https://cdn.example.com/logo-2.png';
+    (mockSupabase.rpc as any)
+      .mockResolvedValueOnce({ data: [{ logo_url: firstUrl }], error: null })
+      .mockResolvedValueOnce({ data: [{ logo_url: secondUrl }], error: null });
+
+    const { result } = renderHook(() =>
+      usePublicEventLogo('event-123', 'Big Event', VALID_ORG_ID, {
+        supabase: mockSupabase
+      })
+    );
+
+    await waitFor(() => expect(result.current.logoUrl).toBe(firstUrl));
+
+    await act(async () => {
+      await result.current.refetch();
+    });
+
+    await waitFor(() => expect(result.current.logoUrl).toBe(secondUrl));
+    expect((mockSupabase.rpc as any)).toHaveBeenCalledTimes(2);
+  });
+
+  it('exposes error state when RPC fails', async () => {
+    (mockSupabase.rpc as any).mockResolvedValue({ data: null, error: { message: 'RPC failed' } });
+
+    const { result } = renderHook(() =>
+      usePublicEventLogo('event-123', 'Big Event', VALID_ORG_ID, {
+        supabase: mockSupabase
+      })
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.logoUrl).toBeNull();
+    expect(result.current.error).toEqual(new Error('RPC failed'));
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('skips image validation when disabled', async () => {
+    const logoUrl = 'https://cdn.example.com/logo.png';
+    (mockSupabase.rpc as any).mockResolvedValue({ data: [{ logo_url: logoUrl }], error: null });
+
+    const { result } = renderHook(() =>
+      usePublicEventLogo('event-123', 'Big Event', VALID_ORG_ID, {
+        supabase: mockSupabase,
+        validateImage: false
+      })
+    );
+
+    await waitFor(() => expect(result.current.logoUrl).toBe(logoUrl));
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('uses custom fallback text generator', () => {
+    const { result } = renderHook(() =>
+      usePublicEventLogo(undefined, 'Public Event', VALID_ORG_ID, {
+        supabase: mockSupabase,
+        generateFallbackText: () => 'CSTM'
+      })
+    );
+
+    expect(result.current.fallbackText).toBe('CSTM');
+    expect(result.current.logoUrl).toBeNull();
+  });
+
+  it('clears cached logo entries when clearPublicLogoCache is called', async () => {
+    const logoUrl = 'https://cdn.example.com/logo.png';
+    (mockSupabase.rpc as any).mockResolvedValue({ data: [{ logo_url: logoUrl }], error: null });
+
+    const { result } = renderHook(() =>
+      usePublicEventLogo('event-123', 'Big Event', VALID_ORG_ID, {
+        supabase: mockSupabase
+      })
+    );
+
+    await waitFor(() => expect(result.current.logoUrl).toBe(logoUrl));
+    expect(getPublicLogoCacheStats().size).toBe(1);
+
+    clearPublicLogoCache();
+    expect(getPublicLogoCacheStats().size).toBe(0);
+  });
+});

package/src/hooks/public/usePublicRouteParams.ts

@@ -58,7 +58,7 @@
 
 import { useState, useEffect, useCallback, useMemo } from 'react';
 import { useParams, useLocation } from 'react-router-dom';
-import type { Event } from '../../types/unified';
+import type { Event } from '../../types/event';
 import { usePublicEvent } from './usePublicEvent';
 
 export interface UsePublicRouteParamsReturn {

package/src/hooks/services/useAuth.ts

@@ -9,7 +9,7 @@
  */
 
 import { useAuthService } from './useAuthService';
-import { type User, type Session, AuthError } from '@supabase/supabase-js';
+import { type User, type Session, type SupabaseClient, AuthError } from '@supabase/supabase-js';
 
 export interface AuthState {
   user: User | null;
@@ -17,8 +17,7 @@ export interface AuthState {
   isAuthenticated: boolean;
   authLoading: boolean;
   authError: AuthError | null;
-  error: AuthError | null; // Alias for authError for backward compatibility
-  supabase: any | null;
+  supabase: SupabaseClient | null;
   
   // Auth methods
   signIn: (email: string, password?: string) => Promise<{ error: AuthError | null }>;
@@ -38,7 +37,6 @@ export function useAuth(): AuthState {
     isAuthenticated: authService.isAuthenticated(),
     authLoading: authService.isLoading(),
     authError: authService.getError(),
-    error: authService.getError(), // Alias for backward compatibility
     supabase: authService.getSupabaseClient(),
     signIn: authService.signIn.bind(authService),
     signUp: authService.signUp.bind(authService),

package/src/hooks/services/useCurrentEvent.ts

@@ -9,7 +9,7 @@
  */
 
 import { useEventService } from './useEventService';
-import { Event } from '../../types/unified';
+import { Event } from '../../types/event';
 
 export interface CurrentEventState {
   events: Event[];

package/src/hooks/useAppConfig.ts

@@ -29,7 +29,7 @@
  */
 
 import { useMemo, useContext } from 'react';
-import { useUnifiedAuth } from '../providers/UnifiedAuthProvider';
+import { useUnifiedAuth } from '../providers/services/UnifiedAuthProvider';
 import { useIsPublicPage, PublicPageContext } from '../components/PublicLayout/PublicPageProvider';
 
 export interface UseAppConfigReturn {

package/src/hooks/useDataTablePerformance.ts

@@ -206,7 +206,7 @@ export function useDataTablePerformance<TData extends DataRecord>({
 
   // Debounced search function
   const debouncedSearch = useCallback(
-    debounce((query: string) => {
+    debounce(((query: string) => {
       if (!searchIndexRef.current) return;
       
       if (!query.trim()) {
@@ -216,7 +216,7 @@ export function useDataTablePerformance<TData extends DataRecord>({
 
       const results = searchIndexRef.current.search(query);
       setSearchResults(results);
-    }, performance.debounceSearch ?? 300),
+    }) as unknown as (...args: unknown[]) => unknown, performance.debounceSearch ?? 300) as (query: string) => void,
     [performance.debounceSearch]
   );
 

package/src/hooks/useEventTheme.ts

@@ -43,7 +43,7 @@ import { useLocation } from 'react-router-dom';
 import { useEvents } from './useEvents';
 import { applyPalette, clearPalette } from '../theming/runtime';
 import { parseAndNormalizeEventColours } from '../theming/parseEventColours';
-import type { Event } from '../types/unified';
+import type { Event } from '../types/event';
 import { createLogger } from '../utils/core/logger';
 
 const log = createLogger('useEventTheme');

package/src/hooks/useEvents.ts

@@ -11,8 +11,9 @@
  * For better performance, consider using useEventService directly.
  */
 
+import { useMemo, useRef } from 'react';
 import { useEventService } from './services/useEventService';
-import { Event } from '../types/unified';
+import { Event } from '../types/event';
 
 export interface EventContextType {
   events: Event[];
@@ -50,16 +51,56 @@ export interface EventContextType {
 export function useEvents(): EventContextType {
   const eventService = useEventService();
 
-  const events = eventService.getEvents();
+  // Get current state - service subscription will trigger re-renders when state changes
+  const rawEvents = eventService.getEvents();
+  const selectedEvent = eventService.getSelectedEvent();
+  const isLoading = eventService.isLoading();
+  const error = eventService.getError();
 
-  return {
+  // Use refs to track previous values and only create new array reference when events actually change
+  const prevEventsRef = useRef<Event[]>([]);
+  const prevEventsIdsRef = useRef<string>('');
+  
+  // Compare event IDs to detect actual changes (more efficient than deep comparison)
+  // Do this outside useMemo to avoid dependency on rawEvents array
+  const currentEventsIds = rawEvents.map(e => e.event_id || e.id).join(',');
+  const eventsChanged = currentEventsIds !== prevEventsIdsRef.current;
+  
+  // Only create new array reference when events actually changed
+  // Update refs synchronously, then memoize based on the ID string
+  if (eventsChanged) {
+    prevEventsRef.current = rawEvents;
+    prevEventsIdsRef.current = currentEventsIds;
+  }
+  
+  // Return stable array reference - only changes when event IDs change
+  const events = useMemo(() => {
+    return prevEventsRef.current;
+  }, [currentEventsIds]);
+
+  // Memoize callbacks to prevent unnecessary re-renders in child components
+  const setSelectedEventCallback = useMemo(
+    () => (event: Event | null) => eventService.setSelectedEvent(event),
+    [eventService]
+  );
+  const refreshEventsCallback = useMemo(
+    () => () => eventService.refreshEvents(),
+    [eventService]
+  );
+  const clearEventSelectionCallback = useMemo(
+    () => () => eventService.clearEventSelection(),
+    [eventService]
+  );
+
+  // Memoize the return object - only recreate when actual values change
+  return useMemo(() => ({
     events,
-    selectedEvent: eventService.getSelectedEvent(),
-    isLoading: eventService.isLoading(),
-    error: eventService.getError(),
-    setSelectedEvent: (event: Event | null) => eventService.setSelectedEvent(event),
-    refreshEvents: () => eventService.refreshEvents(),
-    clearEventSelection: () => eventService.clearEventSelection(),
-  };
+    selectedEvent,
+    isLoading,
+    error,
+    setSelectedEvent: setSelectedEventCallback,
+    refreshEvents: refreshEventsCallback,
+    clearEventSelection: clearEventSelectionCallback,
+  }), [events, selectedEvent?.event_id, isLoading, error?.message, setSelectedEventCallback, refreshEventsCallback, clearEventSelectionCallback]);
 }
 

package/src/hooks/useOrganisationPermissions.test.ts

@@ -11,10 +11,10 @@ import React from 'react';
 import { renderHook, waitFor } from '@testing-library/react';
 import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { useOrganisationPermissions } from './useOrganisationPermissions';
-import { useOrganisations } from '../providers/OrganisationProvider';
+import { useOrganisations } from './useOrganisations';
 
-// Mock the organisation provider
-vi.mock('../providers/OrganisationProvider', () => ({
+// Mock the organisation hook
+vi.mock('./useOrganisations', () => ({
   useOrganisations: vi.fn()
 }));
 

package/src/hooks/useOrganisationPermissions.ts

@@ -46,7 +46,7 @@
  */
 
 import { useMemo } from 'react';
-import { useOrganisations } from '../providers/OrganisationProvider';
+import { useOrganisations } from './useOrganisations';
 import { useOrganisationSecurity } from './useOrganisationSecurity';
 import type { OrganisationRole, OrganisationPermission } from '../types/organisation';
 

package/src/hooks/useOrganisationSecurity.ts

@@ -30,7 +30,7 @@ export interface OrganisationSecurityHook {
   getUserPermissions: (orgId?: string) => Promise<string[]>;
   
   // Audit logging
-  logOrganisationAccess: (action: string, details?: any) => Promise<void>;
+  logOrganisationAccess: (action: string, details?: Record<string, unknown>) => Promise<void>;
   
   // Security utilities
   ensureOrganisationAccess: (orgId: string) => Promise<void>;
@@ -220,7 +220,7 @@ export const useOrganisationSecurity = (): OrganisationSecurityHook => {
   }, [selectedOrganisation, user, getUserRole, superAdminContext.isSuperAdmin]);
 
   // Log organisation access for audit using the new RBAC audit system
-  const logOrganisationAccess = useCallback(async (action: string, details?: any): Promise<void> => {
+  const logOrganisationAccess = useCallback(async (action: string, details?: Record<string, unknown>): Promise<void> => {
     if (!user || !selectedOrganisation) return;
 
     try {

package/src/hooks/usePermissionCache.test.ts

@@ -12,8 +12,9 @@ import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { usePermissionCache } from './usePermissionCache';
 
 // Mock the dependencies
-vi.mock('../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: vi.fn()
+const mockUseUnifiedAuthFn = vi.fn();
+vi.mock('../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
 }));
 
 vi.mock('./useOrganisations', () => ({
@@ -28,12 +29,11 @@ vi.mock('../rbac/api', () => ({
   isPermittedCached: vi.fn()
 }));
 
-import { useUnifiedAuth } from '../providers/UnifiedAuthProvider';
+import { useUnifiedAuth } from '../providers/services/UnifiedAuthProvider';
 import { useOrganisations } from './useOrganisations';
 import { useEvents } from './useEvents';
 import { isPermittedCached } from '../rbac/api';
 
-const mockUseUnifiedAuth = vi.mocked(useUnifiedAuth);
 const mockUseOrganisations = vi.mocked(useOrganisations);
 const mockUseEvents = vi.mocked(useEvents);
 const mockIsPermittedCached = vi.mocked(isPermittedCached);
@@ -43,7 +43,7 @@ describe('usePermissionCache', () => {
     vi.clearAllMocks();
     
     // Setup default mocks
-    mockUseUnifiedAuth.mockReturnValue({
+    mockUseUnifiedAuthFn.mockReturnValue({
       user: { id: 'user-123' },
       session: null,
       appName: 'test-app',
@@ -90,7 +90,7 @@ describe('usePermissionCache', () => {
 
     it('depends on auth and organisation hooks', () => {
       renderHook(() => usePermissionCache());
-      expect(mockUseUnifiedAuth).toHaveBeenCalled();
+      expect(mockUseUnifiedAuthFn).toHaveBeenCalled();
       expect(mockUseOrganisations).toHaveBeenCalled();
     });
   });
@@ -140,7 +140,7 @@ describe('usePermissionCache', () => {
     });
 
     it('handles missing user context gracefully', () => {
-      mockUseUnifiedAuth.mockReturnValueOnce({
+      mockUseUnifiedAuthFn.mockReturnValueOnce({
         user: null,
         session: null,
         appName: 'test-app',
@@ -404,7 +404,7 @@ describe('usePermissionCache', () => {
   describe('Integration with RBAC API', () => {
     it('integrates with auth and organisation hooks correctly', () => {
       renderHook(() => usePermissionCache());
-      expect(mockUseUnifiedAuth).toHaveBeenCalled();
+      expect(mockUseUnifiedAuthFn).toHaveBeenCalled();
       expect(mockUseOrganisations).toHaveBeenCalled();
     });
 
@@ -425,7 +425,7 @@ describe('usePermissionCache', () => {
 
     it('handles permission API state changes', async () => {
       mockIsPermittedCached.mockResolvedValueOnce(true);
-      mockUseUnifiedAuth.mockReturnValueOnce({
+      mockUseUnifiedAuthFn.mockReturnValueOnce({
         user: { id: 'user-456' },
         session: null,
         appName: 'test-app',

package/src/hooks/usePermissionCache.ts

@@ -50,12 +50,12 @@
  * - RBAC API functions - isPermittedCached for permission checking
  * - RBAC types - Type definitions
  * 
- * @deprecated Consider using useCan() or usePermissions() hooks directly instead.
  * This hook provides additional caching on top of the built-in caching in useCan/usePermissions.
+ * Consider using useCan() or usePermissions() hooks directly for simpler use cases.
  */
 
 import { useState, useCallback, useMemo, useEffect, useRef } from 'react';
-import { useUnifiedAuth } from '../providers/UnifiedAuthProvider';
+import { useUnifiedAuth } from '../providers/services/UnifiedAuthProvider';
 import { useOrganisations } from './useOrganisations';
 import { useEvents } from './useEvents';
 import { isPermittedCached } from '../rbac/api';

package/src/index.ts

@@ -17,18 +17,22 @@
 
 // AUTHENTICATION & AUTHORIZATION
 // Note: Providers are now service-based architecture for better testability and maintainability
-export { UnifiedAuthProvider, useUnifiedAuth } from './providers/UnifiedAuthProvider';
-export type { UnifiedAuthProviderProps, UnifiedAuthContextType, UserEventAccess } from './providers/UnifiedAuthProvider';
+export { UnifiedAuthProvider, useUnifiedAuth } from './providers/services/UnifiedAuthProvider';
+export type { UnifiedAuthProviderProps, UnifiedAuthContextType, UserEventAccess } from './providers/services/UnifiedAuthProvider';
 
 // Session tracking utility (for manual use if needed)
 export { useSessionTracking } from './utils/context/sessionTracking';
 
 // Provider components (using service architecture)
-export { EventProvider } from './providers/EventProvider';
+export { EventServiceProvider } from './providers/services/EventServiceProvider';
+export { OrganisationServiceProvider } from './providers/services/OrganisationServiceProvider';
+export { InactivityServiceProvider } from './providers/services/InactivityServiceProvider';
+
+// Convenience provider wrapper (backward compatibility)
 export { OrganisationProvider } from './providers/OrganisationProvider';
-export { InactivityProvider } from './providers/InactivityProvider';
+export type { OrganisationProviderProps } from './providers/OrganisationProvider';
 
-// Convenience hooks for backward compatibility
+// Convenience hooks
 export { useEvents } from './hooks/useEvents';
 export { useOrganisations } from './hooks/useOrganisations';
 
@@ -43,7 +47,6 @@ export type {
   Organisation, 
   OrganisationMembership, 
   OrganisationContextType, 
-  OrganisationProviderProps,
   OrganisationSecurityError 
 } from './types/organisation';
 
@@ -88,7 +91,8 @@ export type { BadgeProps, BadgeVariant } from './components/Badge/Badge';
 export { Checkbox } from './components/Checkbox/Checkbox';
 export { Switch } from './components/Switch/Switch';
 export type { SwitchProps } from './components/Switch/Switch';
-export { Progress } from './components/Progress/Progress';
+export { Progress } from './components/Progress';
+export type { ProgressProps } from './components/Progress';
 
 // ADVANCED UI COMPONENTS
 export {
@@ -180,9 +184,10 @@ export {
 } from './components/DataTable/utils/aggregationUtils';
 
 // FORM COMPONENTS
-export { Form } from './components/Form/Form';
-export { LoginForm } from './components/LoginForm/LoginForm';
-export type { LoginFormProps } from './components/LoginForm/LoginForm';
+export { Form, FormField } from './components/Form/Form';
+export type { FormProps, FormFieldProps } from './components/Form/Form';
+export { LoginForm } from './components/LoginForm';
+export type { LoginFormProps } from './components/LoginForm';
 
 // LAYOUT COMPONENTS
 export { Header } from './components/Header/Header';
@@ -191,7 +196,7 @@ export type { FooterProps } from './components/Footer/Footer';
 
 // NAVIGATION COMPONENTS
 export { NavigationMenu } from './components/NavigationMenu/NavigationMenu';
-export type { NavigationMenuProps, NavigationItem } from './components/NavigationMenu/types';
+export type { NavigationMenuProps, NavigationItem, NavigationMode } from './components/NavigationMenu/NavigationMenu';
 export { UserMenu } from './components/UserMenu/UserMenu';
 export type { UserMenuProps } from './components/UserMenu/UserMenu';
 
@@ -223,7 +228,7 @@ export { createSecureDataAccess } from './utils/security/secureDataAccess';
 export type { UserProfile } from './types/organisation';
 
 // AUTHENTICATION FORMS
-export { PasswordChangeForm } from './components/PasswordReset/PasswordChangeForm';
+export { PasswordChangeForm } from './components/PasswordChange/PasswordChangeForm';
 
 // UTILS & HOOKS
 export { useAppConfig } from './hooks/useAppConfig';
@@ -279,6 +284,8 @@ export {
 export * from './styles';
 // Direct export of theming utilities for convenience
 export { parseAndNormalizeEventColours } from './theming/parseEventColours';
+export { applyPalette, clearPalette } from './theming/runtime';
+export type { PaletteData, ColorPalette, ColorShade } from './theming/runtime';
 
 // PUBLIC PAGES
 export * from './hooks/public';