@jmruthers/pace-core 0.5.181 → 0.5.182

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/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';

package/src/providers/OrganisationProvider.tsx

@@ -1,19 +1,83 @@
 /**
- * @file Re-export for OrganisationProvider
+ * @file Organisation Provider
  * @package @jmruthers/pace-core
  * @module Providers
  * @since 0.1.0
+ *
+ * React provider for organisation context.
+ * This is a convenience wrapper around OrganisationServiceProvider that
+ * automatically gets auth context from UnifiedAuthProvider.
  * 
- * Re-exports the service-based OrganisationProvider for backward compatibility.
+ * Note: If you're using UnifiedAuthProvider, it already includes
+ * OrganisationServiceProvider internally, so this component is mainly
+ * for backward compatibility or standalone usage.
  */
 
-export { OrganisationServiceProvider as OrganisationProvider } from './services/OrganisationServiceProvider';
-export type { OrganisationServiceProviderProps as OrganisationProviderProps } from './services/OrganisationServiceProvider';
+import React from 'react';
+import { useUnifiedAuth } from '../providers/services/UnifiedAuthProvider';
+import { OrganisationServiceProvider } from './services/OrganisationServiceProvider';
+import type { OrganisationProviderProps as BaseOrganisationProviderProps } from '../types/organisation';
 
-// Re-export context and hook
-export { OrganisationServiceContext, useOrganisationService } from './services/OrganisationServiceProvider';
-export type { OrganisationServiceContextType } from './services/OrganisationServiceProvider';
+export interface OrganisationProviderProps extends BaseOrganisationProviderProps {
+  children: React.ReactNode;
+  requireOrganisationContext?: boolean;
+  autoSelectPrimaryOrganisation?: boolean;
+  onOrganisationChange?: (organisation: any) => void;
+}
 
-// Re-export convenience hook for backward compatibility
-export { useOrganisations } from '../hooks/useOrganisations';
+/**
+ * OrganisationProvider component
+ * 
+ * Wraps OrganisationServiceProvider and automatically gets auth context.
+ * 
+ * @example
+ * ```tsx
+ * <UnifiedAuthProvider supabaseClient={supabase} appName="my-app">
+ *   <OrganisationProvider>
+ *     <App />
+ *   </OrganisationProvider>
+ * </UnifiedAuthProvider>
+ * ```
+ */
+export function OrganisationProvider({ 
+  children,
+  requireOrganisationContext,
+  autoSelectPrimaryOrganisation,
+  onOrganisationChange
+}: OrganisationProviderProps) {
+  // Get auth context from UnifiedAuthProvider
+  const authContext = useUnifiedAuth();
+  
+  // If we're inside UnifiedAuthProvider, it already includes OrganisationServiceProvider
+  // So we can just pass through the children
+  // However, if the auth context is not available, we need to handle that
+  if (!authContext) {
+    // If no auth context, we can't provide organisation service
+    // This might happen if used outside UnifiedAuthProvider
+    // In that case, we should probably throw an error or show a message
+    console.warn('OrganisationProvider: No auth context available. Make sure OrganisationProvider is used inside UnifiedAuthProvider.');
+    return <>{children}</>;
+  }
+
+  const { supabase, user, session } = authContext;
+
+  // Wrap with OrganisationServiceProvider
+  // Note: The props like requireOrganisationContext, autoSelectPrimaryOrganisation
+  // are handled by the OrganisationService internally, not by the provider
+  // Note: supabase is mapped to supabaseClient for OrganisationServiceProvider
+  if (!supabase) {
+    console.warn('OrganisationProvider: No supabase client available.');
+    return <>{children}</>;
+  }
+
+  return (
+    <OrganisationServiceProvider
+      supabaseClient={supabase}
+      user={user}
+      session={session}
+    >
+      {children}
+    </OrganisationServiceProvider>
+  );
+}