@jmruthers/pace-core 0.5.181 → 0.5.182

package/src/components/DataTable/__tests__/DataTable.grouping-aggregation.test.tsx

@@ -25,17 +25,20 @@ vi.mock('../../../rbac/hooks', () => ({
   }))
 }));
 
-vi.mock('../../../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: vi.fn(() => ({
-    user: {
-      id: 'test-user',
-      user_metadata: { organisationId: 'test-org' },
-      app_metadata: { organisationId: 'test-org' },
-    },
-    selectedOrganisationId: 'test-org-id',
-    selectedEventId: 'test-event-id',
-    supabase: null,
-  })),
+const mockUseUnifiedAuthFn = vi.fn(() => ({
+  user: {
+    id: 'test-user',
+    user_metadata: { organisationId: 'test-org' },
+    app_metadata: { organisationId: 'test-org' },
+  },
+  selectedOrganisation: { id: 'test-org-id' },
+  selectedEvent: { event_id: 'test-event-id' },
+  supabase: {},
+}));
+
+vi.mock('../../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
 
 // Test data interface

package/src/components/DataTable/__tests__/DataTable.hooks.test.tsx

@@ -44,8 +44,10 @@ const mockUseCan = {
 };
 
 // Mock all the required modules
-vi.mock('../../../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: () => mockUseUnifiedAuth
+const mockUseUnifiedAuthFn = vi.fn(() => mockUseUnifiedAuth);
+vi.mock('../../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
 
 vi.mock('../../../rbac/hooks', () => ({

package/src/components/DataTable/__tests__/DataTable.test.tsx

@@ -27,13 +27,19 @@ vi.mock('../../../rbac/hooks', () => ({
 }));
 
 // Mock the auth provider
-vi.mock('../../../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: vi.fn(() => ({
-    user: { id: 'test-user', email: 'test@example.com' },
-    isAuthenticated: true,
-    isLoading: false,
-    error: null,
-  })),
+const mockUseUnifiedAuthFn = vi.fn(() => ({
+  user: { id: 'test-user', email: 'test@example.com' },
+  isAuthenticated: true,
+  isLoading: false,
+  error: null,
+  selectedOrganisation: { id: 'test-org' },
+  selectedEvent: { event_id: 'test-event' },
+  supabase: {},
+}));
+
+vi.mock('../../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
 
 // Mock the DataTableCore component to focus on DataTable logic

package/src/components/DataTable/__tests__/DataTableCore.test-setup.ts

@@ -24,16 +24,19 @@ vi.mock('../../../rbac/hooks', () => ({
 }));
 
 // Mock the auth provider
-vi.mock('../../../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: vi.fn(() => ({
-    user: { id: 'test-user', email: 'test@example.com' },
-    isAuthenticated: true,
-    isLoading: false,
-    error: null,
-    selectedOrganisationId: 'test-org-id',
-    selectedEventId: 'test-event-id',
-    supabase: null,
-  })),
+const mockUseUnifiedAuthFn = vi.fn(() => ({
+  user: { id: 'test-user', email: 'test@example.com' },
+  isAuthenticated: true,
+  isLoading: false,
+  error: null,
+  selectedOrganisation: { id: 'test-org-id' },
+  selectedEvent: { event_id: 'test-event-id' },
+  supabase: {},
+}));
+
+vi.mock('../../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: (props: { children: React.ReactNode }) => props.children,
 }));
 
 // Mock the performance hook

package/src/components/DataTable/__tests__/DataTableCore.test.tsx

@@ -16,6 +16,7 @@ import { DataTableCore } from '../components/DataTableCore';
 import type { DataTableColumn } from '../types';
 import { createTestData, createTestColumns, testDataScenarios } from './test-utils/dataFactories';
 import { createDefaultFeatures, createReadOnlyFeatures, createFullFeatures } from './test-utils.ts';
+import { renderWithProviders } from '../../../__tests__/helpers/test-utils';
 
 // Mock the RBAC hooks
 vi.mock('../../../rbac/hooks', () => ({
@@ -30,16 +31,19 @@ vi.mock('../../../rbac/hooks', () => ({
 }));
 
 // Mock the auth provider
-vi.mock('../../../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: vi.fn(() => ({
-    user: { id: 'test-user', email: 'test@example.com' },
-    isAuthenticated: true,
-    isLoading: false,
-    error: null,
-    selectedOrganisationId: 'test-org-id',
-    selectedEventId: 'test-event-id',
-    supabase: null,
-  })),
+const mockUseUnifiedAuthFn = vi.fn(() => ({
+  user: { id: 'test-user', email: 'test@example.com' },
+  isAuthenticated: true,
+  isLoading: false,
+  error: null,
+  selectedOrganisation: { id: 'test-org-id' },
+  selectedEvent: { event_id: 'test-event-id' },
+  supabase: {},
+}));
+
+vi.mock('../../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
 
 // Mock the performance hook
@@ -703,7 +707,7 @@ describe('DataTableCore Component', () => {
         effectivePageId: 'test-page',
       });
 
-      render(
+      renderWithProviders(
         <DataTableCore
           data={mockData}
           columns={mockColumns}

package/src/components/DataTable/__tests__/a11y.basic.test.tsx

@@ -28,12 +28,18 @@ vi.mock('../../../rbac/hooks', () => ({
 }));
 
 // Mock the UnifiedAuthProvider
-vi.mock('../../../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: vi.fn(() => ({
-    user: { id: 'test-user', name: 'Test User' },
-    isLoading: false,
-    error: null,
-  })),
+const mockUseUnifiedAuthFn = vi.fn(() => ({
+  user: { id: 'test-user', name: 'Test User' },
+  isLoading: false,
+  error: null,
+  selectedOrganisation: { id: 'test-org' },
+  selectedEvent: { event_id: 'test-event' },
+  supabase: {},
+}));
+
+vi.mock('../../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
 
 // Mock the toast hook

package/src/components/DataTable/__tests__/keyboard.test.tsx

@@ -28,12 +28,18 @@ vi.mock('../../../rbac/hooks', () => ({
 }));
 
 // Mock the UnifiedAuthProvider
-vi.mock('../../../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: vi.fn(() => ({
-    user: { id: 'test-user', name: 'Test User' },
-    isLoading: false,
-    error: null,
-  })),
+const mockUseUnifiedAuthFn = vi.fn(() => ({
+  user: { id: 'test-user', name: 'Test User' },
+  isLoading: false,
+  error: null,
+  selectedOrganisation: { id: 'test-org' },
+  selectedEvent: { event_id: 'test-event' },
+  supabase: {},
+}));
+
+vi.mock('../../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
 
 // Mock the toast hook

package/src/components/DataTable/__tests__/pagination.modes.test.tsx

@@ -62,12 +62,16 @@ const mockRbacConfig = {
 // ============================================================================
 
 // Mock the auth provider
-vi.mock('../../../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: () => ({
-    user: { id: 'test-user', email: 'test@example.com' },
-    organisation: { id: 'test-org' },
-    event: null,
-  }),
+const mockUseUnifiedAuthFn = vi.fn(() => ({
+  user: { id: 'test-user', email: 'test@example.com' },
+  selectedOrganisation: { id: 'test-org' },
+  selectedEvent: null,
+  supabase: {},
+}));
+
+vi.mock('../../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
 
 // Mock RBAC hooks

package/src/components/DataTable/__tests__/test-utils/sharedTestUtils.tsx

@@ -10,7 +10,7 @@
 
 import { vi } from 'vitest';
 import type { DataTableColumn, DataTableAction, DataTableFeatureConfig } from '../../types';
-import { AccessLevel } from '../../../../types/unified';
+// AccessLevel removed - use AccessLevel type from rbac/types.ts if needed
 import '@testing-library/jest-dom';
 import React from 'react';
 

package/src/components/DataTable/components/DataTableBody.tsx

@@ -57,27 +57,27 @@
  */
 
 import React from 'react';
-import { type Table, flexRender } from '@tanstack/react-table';
+import { type Table, flexRender, type Column } from '@tanstack/react-table';
 import { Button } from '../../Button/Button';
 import { ChevronUp, ChevronDown, ChevronRight, ChevronsUpDown } from 'lucide-react';
 import { EmptyState } from './EmptyState';
 import { Input } from '../../Input/Input';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '../../Select/Select';
-import type { AggregateConfig } from '../types';
+import type { AggregateConfig, DataRecord } from '../types';
 
 /**
  * Props for the DataTable body component
  * @template TData - The type of data records in the table
  */
-interface DataTableBodyProps<TData extends Record<string, any>> {
+interface DataTableBodyProps<TData extends DataRecord> {
   /** TanStack table instance */
   table: Table<TData>;
   /** Whether a new row is being created */
   isCreating: boolean;
   /** Data for the row being created */
-  creationData: Record<string, any>;
+  creationData: Record<string, unknown>;
   /** Callback when creation data changes */
-  onCreationDataChange: (data: Record<string, any>) => void;
+  onCreationDataChange: (data: Record<string, unknown>) => void;
   /** Callback to save the new row */
   onSaveCreation: () => void;
   /** Callback to cancel row creation */
@@ -85,9 +85,9 @@ interface DataTableBodyProps<TData extends Record<string, any>> {
   /** ID of the row currently being edited */
   editingRowId: string | null;
   /** Data for the row being edited */
-  editingData: Record<string, any>;
+  editingData: Record<string, unknown>;
   /** Callback when editing data changes */
-  onEditingDataChange: (data: Record<string, any>) => void;
+  onEditingDataChange: (data: Record<string, unknown>) => void;
   /** Current grouping configuration */
   grouping: string[];
   /** Aggregate configurations for grouped data */
@@ -156,8 +156,8 @@ const renderEditField = (
           <SelectValue placeholder={placeholder || `Select ${column.id}`} />
         </SelectTrigger>
         <SelectContent>
-          {columnDef.fieldOptions.map((option: any) => (
-            <SelectItem key={option.value} value={String(option.value)}>
+          {columnDef.fieldOptions.map((option: { value: unknown; label: string }) => (
+            <SelectItem key={String(option.value) || option.label} value={String(option.value)}>
               {option.label}
             </SelectItem>
           ))}
@@ -189,7 +189,7 @@ const renderEditField = (
   );
 };
 
-export function DataTableBody<TData extends Record<string, any>>({
+export function DataTableBody<TData extends DataRecord>({
   table,
   isCreating,
   creationData,
@@ -208,21 +208,6 @@ export function DataTableBody<TData extends Record<string, any>>({
   hierarchical,
 }: DataTableBodyProps<TData>) {
   
-  // Debug logging
-  console.log('🔍 DataTableBody Debug:', {
-    rowModelLength: table.getRowModel().rows.length,
-    totalRowCount: table.getRowCount(),
-    groupingEnabled: grouping.length > 0,
-    grouping: grouping,
-    rowAnalysis: table.getRowModel().rows.map(row => ({
-      id: row.id,
-      isGrouped: row.getIsGrouped(),
-      hasParent: !!(typeof row.getParentRow === 'function' ? row.getParentRow() : false),
-      subRowsCount: row.subRows?.length || 0,
-      originalData: row.original?.meal_code || row.original?.id || 'no-id',
-    })),
-    paginationState: table.getState().pagination,
-  });
 
   return (
     <>

package/src/components/DataTable/components/DataTableCore.tsx

@@ -47,7 +47,7 @@ import { useCan, useResolvedScope } from '../../../rbac/hooks';
 import { toast } from '../../../hooks/useToast';
 import { exportToCSV, exportToCSVWithTableRows } from '../utils/exportUtils';
 import type { ExportOptions } from '../types';
-import { useUnifiedAuth } from '../../../providers/UnifiedAuthProvider';
+import { useUnifiedAuth } from '../../../providers/services/UnifiedAuthProvider';
 import { Scope } from '../../../rbac/types';
 import { useDataTablePermissions } from '../hooks/useDataTablePermissions';
 import { useTableColumns } from '../hooks/useTableColumns';

package/src/components/DataTable/components/FilterRow.tsx

@@ -2,6 +2,8 @@ import React from 'react';
 import { ColumnFilter } from './ColumnFilter';
 import type { Header, Table } from '@tanstack/react-table';
 import { getColumnHeaderText } from '../utils/columnUtils';
+import type { Column } from '@tanstack/react-table';
+import type { DataRecord } from '../types';
 
 interface FilterRowProps<TData> {
   table: Table<TData>;
@@ -114,7 +116,7 @@ export function FilterRow<TData>({ table, visibleColumns }: FilterRowProps<TData
                 column={column}
                 filterType={filterType}
                 options={options}
-                placeholder={`Filter ${getColumnHeaderText(column)}...`}
+                placeholder={`Filter ${getColumnHeaderText(column as unknown as Column<DataRecord, unknown>)}...`}
               />
             ) : (
               <div className="h-8 flex items-center text-sec-400 text-sm">

package/src/components/DataTable/components/ImportModal.tsx

@@ -39,7 +39,7 @@ import React, { useState, useRef, useEffect } from 'react';
 import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from '../../Dialog';
 import { Button } from '../../Button/Button';
 import { Input } from '../../Input/Input';
-import { Progress } from '../../Progress/Progress';
+import { Progress } from '../../Progress';
 import { Upload, FileText, AlertCircle } from 'lucide-react';
 import { createLogger } from '../../../utils/core/logger';
 

package/src/components/DataTable/components/VirtualizedDataTable.tsx

@@ -7,7 +7,7 @@
 
 import React, { useMemo, useRef, useCallback, memo, useLayoutEffect, useState } from 'react';
 import { useVirtualizer } from '@tanstack/react-virtual';
-import { flexRender, type Table as TanStackTable } from '@tanstack/react-table';
+import { flexRender, type Table as TanStackTable, type Cell, type Row } from '@tanstack/react-table';
 import { cn } from '../../../utils/core/cn';
 import type { DataRecord } from '../types';
 
@@ -22,7 +22,7 @@ export interface VirtualizedDataTableProps<TData extends DataRecord> {
 /**
  * Memoized cell component for performance
  */
-const MemoizedCell = memo(({ cell, style }: { cell: any; style?: React.CSSProperties }) => {
+const MemoizedCell = memo(<TData extends DataRecord>({ cell, style }: { cell: Cell<TData, unknown>; style?: React.CSSProperties }) => {
   return (
     <td
       key={cell.id}
@@ -42,8 +42,8 @@ MemoizedCell.displayName = 'MemoizedCell';
 /**
  * Memoized row component for performance
  */
-const MemoizedRow = memo(({ row, style }: { 
-  row: any; 
+const MemoizedRow = memo(<TData extends DataRecord>({ row, style }: { 
+  row: Row<TData>; 
   style: React.CSSProperties;
 }) => {
   return (
@@ -56,10 +56,10 @@ const MemoizedRow = memo(({ row, style }: {
       style={style}
       data-testid={`data-table-row-${row.id}`}
     >
-      {row.getVisibleCells && row.getVisibleCells().map((cell: any) => (
+      {row.getVisibleCells && row.getVisibleCells().map((cell) => (
         <MemoizedCell
           key={cell.id} 
-          cell={cell}
+          cell={cell as unknown as Cell<DataRecord, unknown>}
           style={{}}
         />
       ))}
@@ -276,12 +276,12 @@ export interface EnhancedVirtualizedDataTableProps<TData extends DataRecord>
   // Additional props for DataTable integration
   variant?: 'default' | 'compact' | 'spacious';
   enableGrouping?: boolean;
-  actions?: any[];
+  actions?: unknown[];
   enableEditing?: boolean;
   enableDeletion?: boolean;
   onEditRow?: (row: TData, data: Partial<TData>) => void;
   onDeleteRow?: (row: TData) => void;
-  getRowId?: (row: any) => string;
+  getRowId?: (row: TData) => string;
 }
 
 export function EnhancedVirtualizedDataTable<TData extends DataRecord>({
@@ -468,7 +468,7 @@ export function EnhancedVirtualizedDataTable<TData extends DataRecord>({
                   );
                 }
 
-                const row = displayRow as any;
+                const row = displayRow as Row<TData>;
                 return (
                   <MemoizedRow
                     key={row.id}

package/src/components/DataTable/core/ColumnFactory.ts

@@ -18,7 +18,7 @@ export interface TextColumnOptions {
   filterable?: boolean;
   groupable?: boolean;
   hideable?: boolean;
-  render?: (value: any) => React.ReactNode;
+  render?: (value: unknown) => React.ReactNode;
   footer?: React.ReactNode;
   size?: number;
   minSize?: number;
@@ -35,7 +35,7 @@ export interface DateColumnOptions extends TextColumnOptions {
   dateOptions?: Intl.DateTimeFormatOptions;
 }
 
-export interface BooleanColumnOptions extends TextColumnOptions {
+export interface BooleanColumnOptions extends Omit<TextColumnOptions, 'render'> {
   render?: (value: boolean) => React.ReactNode;
 }
 
@@ -47,13 +47,13 @@ export interface ActionColumnOptions {
   maxSize?: number;
   meta?: {
     align?: 'left' | 'right' | 'center';
-    [key: string]: any;
+    [key: string]: unknown;
   };
 }
 
 export interface CustomColumnOptions<TData extends DataRecord> {
   header?: string;
-  cell?: (info: any) => React.ReactNode;
+  cell?: (info: unknown) => React.ReactNode;
   enableSorting?: boolean;
   enableColumnFilter?: boolean;
   enableGrouping?: boolean;
@@ -150,7 +150,7 @@ export class ColumnFactory<TData extends DataRecord = DataRecord> {
         const value = getValue();
         if (!value) return '';
         
-        const date = new Date(value as any);
+        const date = new Date(String(value));
         if (isNaN(date.getTime())) return String(value);
         
         if (options.format) {
@@ -211,7 +211,7 @@ export class ColumnFactory<TData extends DataRecord = DataRecord> {
       enableHiding: false,
       cell: ({ row }) => {
         if (options.render) {
-          return options.render(row.original, actions as any);
+          return options.render(row.original, actions as DataTableAction<DataRecord>[]);
         }
         
         // Return a simple object that can be rendered by the component

package/src/components/DataTable/core/DataTableContext.tsx

@@ -14,7 +14,8 @@ import { Checkbox } from '../../Checkbox/Checkbox';
 // DropdownMenu components have been merged into Select components
 import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogTrigger } from '../../Dialog/Dialog';
 import type { DataTableContext as IDataTableContext, DataTableConfig, DataTableUtils } from './interfaces';
-import type { DataRecord } from '../types';
+import type { DataRecord, DataTableAction } from '../types';
+import type { ColumnDef } from '@tanstack/react-table';
 import { DataManager } from './DataManager';
 import { ColumnManagerImpl } from './ColumnManager';
 import { ActionManagerImpl } from './ActionManager';
@@ -23,7 +24,7 @@ import { PluginRegistryImpl } from './PluginRegistry';
 import { LocalDataAdapter } from './LocalDataAdapter';
 
 // Create the context
-const DataTableContext = createContext<IDataTableContext<any> | null>(null);
+const DataTableContext = createContext<IDataTableContext<DataRecord> | null>(null);
 
 /**
  * DataTable provider component
@@ -32,8 +33,8 @@ export interface DataTableProviderProps<TData extends DataRecord> {
   children: React.ReactNode;
   config: DataTableConfig<TData>;
   data?: TData[];
-  columns?: any[];
-  actions?: any[];
+  columns?: ColumnDef<TData>[];
+  actions?: DataTableAction<TData>[];
   pageSize?: number;
 }
 
@@ -80,12 +81,15 @@ export function DataTableProvider<TData extends DataRecord>({
 
   // Create utilities
   const utils: DataTableUtils<TData> = useMemo(() => ({
-    getRowId: (row: TData, index: number) => (row as any).id || String(index),
-    formatValue: (value: any, column: any) => String(value),
+    getRowId: (row: TData, index: number) => {
+      const record = row as Record<string, unknown>;
+      return (record.id ? String(record.id) : String(index));
+    },
+    formatValue: (value: unknown, column: ColumnDef<TData>) => String(value),
     validateData: (data: Partial<TData>) => null,
-    debounce: <T extends (...args: any[]) => any>(func: T, delay: number) => {
+    debounce: <T extends (...args: unknown[]) => unknown>(func: T, delay: number) => {
       let timeoutId: NodeJS.Timeout;
-      return ((...args: any[]) => {
+      return ((...args: unknown[]) => {
         clearTimeout(timeoutId);
         timeoutId = setTimeout(() => func(...args), delay);
       }) as T;
@@ -135,7 +139,7 @@ export function DataTableProvider<TData extends DataRecord>({
   }, [actions, actionManager, stateManager]);
 
   return (
-    <DataTableContext.Provider value={contextValue}>
+    <DataTableContext.Provider value={contextValue as unknown as IDataTableContext<DataRecord>}>
       {children}
     </DataTableContext.Provider>
   );
@@ -149,7 +153,7 @@ export function useDataTableContext<TData extends DataRecord = DataRecord>(): ID
   if (!context) {
     throw new Error('useDataTableContext must be used within a DataTableProvider');
   }
-  return context as IDataTableContext<TData>;
+  return context as unknown as IDataTableContext<TData>;
 }
 
 /**

package/src/components/DataTable/core/LocalDataAdapter.ts

@@ -228,7 +228,8 @@ export class LocalDataAdapter<TData extends DataRecord = DataRecord> implements
    * Get row ID from data item
    */
   private getRowId(item: TData): string {
-    return (item as any).id || (item as any).key || JSON.stringify(item);
+    const record = item as Record<string, unknown>;
+    return (record.id ? String(record.id) : record.key ? String(record.key) : JSON.stringify(item));
   }
 
   /**

package/src/components/DataTable/core/PluginRegistry.ts

@@ -39,7 +39,7 @@ export class PluginRegistryImpl<TData extends DataRecord = DataRecord> implement
     // Cleanup if initialized
     if (this.initializedPlugins.has(name)) {
       plugin.cleanup().catch(error => {
-        console.error(`Error cleaning up plugin "${name}":`, error);
+        // Error logged silently - plugin cleanup failures should not break the app
       });
       this.initializedPlugins.delete(name);
     }
@@ -118,7 +118,7 @@ export class PluginRegistryImpl<TData extends DataRecord = DataRecord> implement
         await plugin.initialize(context);
         this.initializedPlugins.add(plugin.name);
       } catch (error) {
-        console.error(`Failed to initialize plugin "${plugin.name}":`, error);
+        // Re-throw error - initialization failures should be handled by caller
         throw error;
       }
     }
@@ -136,7 +136,7 @@ export class PluginRegistryImpl<TData extends DataRecord = DataRecord> implement
           await plugin.cleanup();
           this.initializedPlugins.delete(plugin.name);
         } catch (error) {
-          console.error(`Error cleaning up plugin "${plugin.name}":`, error);
+          // Error logged silently - plugin cleanup failures should not break the app
         }
       }
     }