@jmruthers/pace-core 0.6.6 → 0.6.8

package/cursor-rules/09-operations.mdc

@@ -0,0 +1,365 @@
+---
+description: Enforce error handling patterns, performance optimization, and CI/CD integration patterns
+globs: ["src/**/*.{ts,tsx,js,jsx}", "supabase/migrations/**/*.sql", ".github/workflows/**/*.{yml,yaml}", "package.json"]
+alwaysApply: false
+paceCoreVersion: "0.6.x"
+rulesVersion: "2025-01-28"
+---
+# Operations Standards Guide
+
+**📚 Human-Readable Standard**: See [9-operations-standards.md](../../packages/core/docs/standards/9-operations-standards.md) for complete documentation.
+
+This guide enforces error handling patterns, performance optimization strategies, and CI/CD integration patterns.
+
+## AI Agent Instructions
+
+**When writing or modifying code, ALWAYS:**
+1. **Use type-safe errors** - Never use `any` for errors, always use type guards or Result types
+2. **Never expose internals** - User-facing errors must be friendly, never show SQL, stack traces, or file paths
+3. **Log with context** - Always log errors with context, but never log sensitive data (passwords, tokens, PII)
+4. **Memoize expensive operations** - Use `useMemo` for expensive computations, `useCallback` for stable references
+5. **Avoid new objects in render** - Never create new objects/arrays in render, memoize them with `useMemo`
+6. **Use helper functions in RLS** - Always use STABLE SECURITY DEFINER helper functions, never subqueries
+7. **Provide recovery paths** - When possible, provide retry logic or fallback values
+
+**Decision Tree: Error Handling**
+```
+1. What type of error is this?
+   ├─ API Error → Use ApiResult shape, user-friendly message
+   ├─ Validation Error → Use Zod errors, field-specific messages
+   ├─ Network Error → Retry logic, connection message
+   └─ Unknown Error → Generic user message, detailed log
+
+2. Should user see this error?
+   ├─ YES → User-friendly message (no internals)
+   └─ NO → Log only, show generic message
+
+3. Can we recover?
+   ├─ YES → Retry logic or fallback value
+   └─ NO → Show error, allow user to retry
+```
+
+**Decision Tree: Performance**
+```
+1. Is this expensive computation?
+   ├─ YES → Use useMemo
+   └─ NO → Don't memoize (overhead not worth it)
+
+2. Is this function passed as prop?
+   ├─ YES → Use useCallback
+   └─ NO → Regular function is fine
+
+3. Is this creating new object/array in render?
+   ├─ YES → Memoize with useMemo
+   └─ NO → Continue
+```
+
+## Error Handling Patterns
+
+### MUST: Use Type-Safe Error Handling
+
+**MUST use type guards or Result types, NEVER use `any`:**
+
+```tsx
+// ❌ WRONG: Using any
+catch (error: any) {
+  console.log(error.message);
+}
+
+// ✅ CORRECT: Type guard
+function isApiError(error: unknown): error is ApiError {
+  return typeof error === 'object' && error !== null && 'ok' in error && (error as ApiError).ok === false;
+}
+catch (error) {
+  if (isApiError(error)) {
+    handleApiError(error);
+  } else {
+    handleUnknownError(error);
+  }
+}
+
+// ✅ CORRECT: Result type
+type Result<T> = { ok: true; data: T } | { ok: false; error: ApiError };
+const result = await fetchData();
+if (result.ok) {
+  useData(result.data);
+} else {
+  showError(result.error.message);
+}
+```
+
+### MUST: Never Expose Internal Details
+
+**MUST NOT expose SQL, stack traces, file paths, or internal errors to users:**
+
+```tsx
+// ❌ WRONG: Exposing internal details
+toast.error(error.message); // May contain SQL, stack traces
+
+// ✅ CORRECT: User-friendly message
+toast.error('Unable to save changes. Please try again.');
+logger.error('Save failed', { error: error.message, context: 'saveUser' });
+```
+
+### MUST: Use Consistent Error Shapes
+
+**MUST use ApiResult shape for API errors:**
+
+```tsx
+// ✅ CORRECT: Consistent error shape
+type ApiError = {
+  ok: false;
+  error: {
+    code: string;
+    message: string; // User-friendly
+    details?: object; // Non-sensitive context
+  };
+};
+```
+
+### MUST: Log Errors with Context
+
+**MUST log errors with context, but NEVER log sensitive data:**
+
+```tsx
+// ✅ CORRECT: Log with context, no sensitive data
+logger.error('Failed to save user', {
+  userId: user.id,
+  operation: 'updateUser',
+  errorCode: error.code,
+});
+
+// ❌ WRONG: Logging sensitive data
+logger.error('Failed to save user', {
+  password: user.password, // NEVER
+  token: authToken,        // NEVER
+});
+```
+
+### SHOULD: Provide Recovery Paths
+
+**SHOULD provide retry logic or fallback values when appropriate:**
+
+```tsx
+// ✅ CORRECT: Retry with exponential backoff
+async function fetchWithRetry<T>(fn: () => Promise<Result<T>>, maxRetries = 3): Promise<Result<T>> {
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    const result = await fn();
+    if (result.ok) return result;
+    if (result.error.code?.startsWith('4')) return result; // Don't retry 4xx
+    await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
+  }
+  return { ok: false, error: { code: 'MAX_RETRIES', message: 'Operation failed after retries' } };
+}
+```
+
+## Performance Optimization Patterns
+
+### MUST: Optimize React Re-renders
+
+**MUST use memoization for expensive computations and stable references:**
+
+```tsx
+// ✅ CORRECT - Memoize expensive computation
+const expensiveValue = useMemo(() => computeExpensiveValue(data), [data]);
+
+// ✅ CORRECT - Stable callback reference
+const handleClick = useCallback(() => doSomething(id), [id]);
+
+// ✅ CORRECT - Memoize component
+const ExpensiveComponent = React.memo(({ data }) => <div>{/* ... */}</div>);
+```
+
+### MUST: Avoid Creating New Objects in Render
+
+**MUST NOT create new objects/arrays in render:**
+
+```tsx
+// ❌ WRONG - New object on every render
+function Component({ items }) {
+  const config = { items, enabled: true };
+  return <Child config={config} />;
+}
+
+// ✅ CORRECT - Memoize object
+function Component({ items }) {
+  const config = useMemo(() => ({ items, enabled: true }), [items]);
+  return <Child config={config} />;
+}
+```
+
+### MUST: Use Helper Functions in RLS Policies
+
+**MUST use STABLE SECURITY DEFINER helper functions (never subqueries):**
+
+```sql
+-- ✅ CORRECT - Helper function (evaluated once)
+CREATE POLICY "rbac_select_users" ON users FOR SELECT USING (
+  check_user_organisation_access(organisation_id)
+);
+
+-- ❌ WRONG - Subquery (N+1 performance issue)
+CREATE POLICY "rbac_select_users" ON users FOR SELECT USING (
+  organisation_id IN (SELECT organisation_id FROM organisation_memberships WHERE user_id = auth.uid())
+);
+```
+
+### SHOULD: Lazy Load Heavy Components
+
+**SHOULD lazy load heavy components:**
+
+```tsx
+// ✅ CORRECT - Lazy load
+import { lazy, Suspense } from 'react';
+const HeavyComponent = lazy(() => import('./HeavyComponent'));
+<Suspense fallback={<Loading />}><HeavyComponent /></Suspense>
+```
+
+### SHOULD: Configure TanStack Query Cache
+
+**SHOULD configure appropriate cache times:**
+
+```tsx
+// ✅ CORRECT - Configure cache
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 5 * 60 * 1000,
+      cacheTime: 10 * 60 * 1000,
+      retry: 1,
+      refetchOnWindowFocus: false,
+    },
+  },
+});
+```
+
+## CI/CD Integration Patterns
+
+### MUST: Include Required CI Checks
+
+**MUST run these checks in every CI pipeline:**
+
+```yaml
+# ✅ CORRECT - Required checks
+jobs:
+  quality-checks:
+    steps:
+      - name: Lint
+        run: npm run lint
+      - name: Type check
+        run: npx tsc --noEmit
+      - name: Run tests
+        run: npm run test
+      - name: Build
+        run: npm run build
+```
+
+### MUST: Have Required Scripts
+
+**MUST have these scripts in package.json:**
+
+```json
+// ✅ CORRECT - Required scripts
+{
+  "scripts": {
+    "lint": "eslint .",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "build": "vite build"
+  }
+}
+```
+
+### MUST: Use Secrets for Sensitive Data
+
+**MUST NOT commit secrets to repository:**
+
+```yaml
+# ✅ CORRECT - Use secrets
+env:
+  SUPABASE_URL: ${{ secrets.SUPABASE_URL }}
+  VITE_SUPABASE_ANON_KEY: ${{ secrets.VITE_SUPABASE_ANON_KEY }}
+
+# ❌ WRONG - Hardcoded secrets
+env:
+  SUPABASE_URL: "https://hardcoded-url.supabase.co"
+```
+
+### SHOULD: Deploy to Staging First
+
+**SHOULD deploy to staging before production:**
+
+```yaml
+# ✅ CORRECT - Staging first
+deploy-staging:
+  if: github.ref == 'refs/heads/develop'
+  environment: staging
+
+deploy-production:
+  needs: deploy-staging
+  if: github.ref == 'refs/heads/main'
+  environment: production
+```
+
+## Common Mistakes to Avoid
+
+**When writing code, NEVER:**
+1. **Use `any` for errors** - Always use type guards or Result types
+   ```tsx
+   // ❌ WRONG
+   catch (error: any) {
+     toast.error(error.message);
+   }
+   
+   // ✅ CORRECT
+   catch (error: unknown) {
+     if (isApiError(error)) {
+       toast.error(error.error.message);
+     } else {
+       toast.error('An unexpected error occurred');
+     }
+   }
+   ```
+
+2. **Expose internal details in errors** - Always use user-friendly messages
+3. **Create new objects in render** - Always memoize with useMemo
+4. **Skip memoization for expensive operations** - Always use useMemo/useCallback
+5. **Use subqueries in RLS policies** - Always use STABLE SECURITY DEFINER helper functions
+6. **Log sensitive data** - Never log passwords, tokens, or PII
+
+## Operations Checklist
+
+Before committing, verify:
+
+**Error Handling:**
+- [ ] Type-safe error handling (no `any`)
+- [ ] User-friendly error messages (no internals)
+- [ ] Errors logged with context (no sensitive data)
+- [ ] Recovery paths provided when possible
+- [ ] Consistent error shapes used
+
+**Performance:**
+- [ ] Expensive computations memoized
+- [ ] Callbacks stable with useCallback
+- [ ] Components memoized when appropriate
+- [ ] No new objects/arrays in render
+- [ ] Heavy components lazy loaded
+- [ ] RLS policies use helper functions
+- [ ] TanStack Query configured properly
+
+**CI/CD:**
+- [ ] Lint check configured
+- [ ] Type check configured
+- [ ] Tests run in CI
+- [ ] Build succeeds in CI
+- [ ] Environment variables set as secrets
+- [ ] Staging deployment configured
+- [ ] Production deployment configured
+
+## Reference
+
+**Note**: CI/CD configuration validation and performance metric thresholds are handled by CI/audit tool. See [9-operations-standards.md](../../packages/core/docs/standards/9-operations-standards.md) for complete enforcement details.
+
+- Error Handling: [9-operations-standards.md](../../packages/core/docs/standards/9-operations-standards.md#error-handling-patterns)
+- Performance: [9-operations-standards.md](../../packages/core/docs/standards/9-operations-standards.md#performance-optimization)
+- CI/CD: [9-operations-standards.md](../../packages/core/docs/standards/9-operations-standards.md#cicd-integration)

package/dist/DataTable-6RMSCQJ6.js

@@ -0,0 +1,15 @@
+export { ActionButtons, BulkOperationsDropdown, ColumnFactory, ColumnVisibilityDropdown, DataTable, DataTableCore, DataTableErrorBoundary, DataTableModals, DataTableToolbar, EditableRow, EmptyState, EnhancedPaginationControls, GroupingDropdown, ImportModal, LoadingState, PaginationControls, SortIndicator, UnifiedTableBody, announce, announceBulkOperation, announceFilterChange, announceLoadingState, announcePaginationChange, announceSearchResults, announceSelectionChange, announceSortChange, average, calculateAllDepths, calculateAllIndentation, calculateIndentation, calculateOptimalPageSize, cleanupLiveRegion, count, createHierarchicalStructure, defaultDataTableFeatures, exportToCSV, exportToCSVWithTableRows, generateCSVContent, getAriaSortState, getAriaSortValue, getCellRenderer, getColumnHeaderText, getHierarchicalSortConfig, getPageSizeOptions, getPaginationBinding, getRowDepth, getRowDescription, getRowIdSafe, getSortButtonLabel, groupHierarchicalData, hasValidRowId, initializeLiveRegion, isHierarchicalSortableColumn, max, min, normalizeDataTableFeatures, shouldShowColumnForRow, sortHierarchicalDataByStructure, sortHierarchicalDataWithSorting, sum, validateHierarchicalData, validatePaginationConfig } from './chunk-NKHKXPI4.js';
+import './chunk-GS5672WG.js';
+export { CircuitBreaker, DEFAULT_FALLBACK_CONFIG, DataChunkManager, DataTableError, DataTableErrorType, ErrorRecoveryManager, MemoryMonitor, SearchIndex, VisibilityTracker, chunkData, debounce, determinePaginationMode, getOptimalPageSizeOptions, safeExecute, throttle, useDataTablePerformance } from './chunk-S7DKJPLT.js';
+import './chunk-EF2UGZWY.js';
+import './chunk-C7NSAPTL.js';
+import './chunk-T5CVK4R3.js';
+import './chunk-LX6U42O3.js';
+import './chunk-AHU7G2R5.js';
+import './chunk-4SXLQIZO.js';
+import './chunk-A3W6LW53.js';
+import './chunk-OJ4SKRSV.js';
+import './chunk-7ILTDCL2.js';
+import './chunk-HF6O3O37.js';
+import './chunk-TTRFSOKR.js';
+import './chunk-3RG5ZIWI.js';

package/dist/{DataTable-2N_tqbfq.d.ts → DataTable-DRUIgtUH.d.ts}

@@ -1,5 +1,5 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { d as DataRecord, D as DataTableColumn, e as DataTableRBACConfig, f as DataTableFeatureConfig, H as HierarchicalConfig, g as PerformanceConfig, S as ServerSideConfig, h as PaginationMode, C as ChunkingConfig, i as SearchIndexConfig, j as ExportOptions, G as GetRowId, E as EmptyStateConfig, c as AggregateConfig, a as DataTableAction } from './types-B-K_5VnO.js';
+import { d as DataRecord, D as DataTableColumn, e as DataTableRBACConfig, f as DataTableFeatureConfig, H as HierarchicalConfig, g as PerformanceConfig, S as ServerSideConfig, h as PaginationMode, C as ChunkingConfig, i as SearchIndexConfig, j as ExportOptions, G as GetRowId, E as EmptyStateConfig, c as AggregateConfig, a as DataTableAction } from './types-DXstZpNI.js';
 import React__default from 'react';
 
 /**

package/dist/{PublicPageProvider-BBH6Vqg7.d.ts → PublicPageProvider-CIGSujI2.d.ts}

@@ -1,7 +1,7 @@
 import * as React$1 from 'react';
 import React__default, { ReactNode, Component } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { P as ParsedAddress, A as AutocompleteOptions } from './types-B-K_5VnO.js';
+import { P as ParsedAddress, A as AutocompleteOptions } from './types-DXstZpNI.js';
 import * as LabelPrimitive from '@radix-ui/react-label';
 import { F as FileCategory, e as FileUploadResult, U as UploadProgress, c as FileUploadOptions, a as FileReference } from './file-reference-BavO2eQj.js';
 import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
@@ -473,27 +473,32 @@ declare namespace Textarea {
  * Features:
  * - Multiple visual variants (default, destructive, inline)
  * - Title and description support
- * - Semantic HTML: renders as `<aside>` element
- * - ARIA role="alert" for accessibility
+ * - Semantic HTML: renders as `<p>` element with `role="alert"` (default) or custom role
  * - Keyboard and screen reader accessible
  * - Composable with icons and actions
  * - Inline variant for lightweight text formatting
  *
  * @example
  * ```tsx
- * // Basic alert (renders as <aside> with <h5> title and <p> description)
+ * // Basic alert (renders as <p role="alert"> with <h5> title and <p> description)
  * <Alert>
  *   <AlertTitle>Success</AlertTitle>
  *   <AlertDescription>Your changes have been saved.</AlertDescription>
  * </Alert>
  *
- * // Destructive alert with icon (renders as <aside> with <h5> title and <p> description)
+ * // Destructive alert with icon (renders as <p role="alert"> with <h5> title and <p> description)
  * <Alert variant="destructive">
  *   <ErrorIcon />
  *   <AlertTitle>Error</AlertTitle>
  *   <AlertDescription>Something went wrong.</AlertDescription>
  * </Alert>
  *
+ * // Status message (renders as <p role="status"> for informational messages)
+ * <Alert role="status" aria-live="polite">
+ *   <AlertTitle>No data available</AlertTitle>
+ *   <AlertDescription>Get started by adding your first entry.</AlertDescription>
+ * </Alert>
+ *
  * // Inline alert (renders as React.Fragment with <strong> title and <span> description)
  * <Alert variant="inline">
  *   <AlertTitle>Note:</AlertTitle>
@@ -502,15 +507,16 @@ declare namespace Textarea {
  * ```
  *
  * @accessibility
- * - Uses semantic HTML: `<aside>` element for better semantic meaning
- * - Uses role="alert" for screen reader announcement
+ * - Uses semantic HTML: `<p>` element with `role="alert"` (default) for screen reader announcements
+ * - Can be customized with `role="status"` for informational messages
  * - Title and description are semantically structured
  * - Supports keyboard navigation and focus
  */
 
-declare const Alert: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLElement> & {
+declare const Alert: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & {
     variant?: "default" | "destructive" | "inline";
-} & React$1.RefAttributes<HTMLElement>>;
+    role?: string;
+} & React$1.RefAttributes<HTMLParagraphElement>>;
 declare const AlertTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLHeadingElement>>;
 declare const AlertDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
 
@@ -912,9 +918,9 @@ interface DialogContentProps extends React$1.HTMLAttributes<HTMLDialogElement> {
     minHeight?: string;
     /** Minimum width in CSS units */
     minWidth?: string;
-    /** Dialog title for accessibility (sets native title attribute) */
+    /** Dialog title - sets native title attribute and aria-labelledby */
     title?: string;
-    /** Dialog description for accessibility (sets aria-description attribute) */
+    /** Dialog description - sets native aria-description attribute */
     description?: string;
     /** Whether to persist open state across tab switches */
     persistOpenState?: boolean;
@@ -926,12 +932,6 @@ interface DialogContentProps extends React$1.HTMLAttributes<HTMLDialogElement> {
 interface DialogPortalProps {
     children: React$1.ReactNode;
 }
-/**
- * Props for the DialogClose component
- * @public
- */
-interface DialogCloseProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
-}
 /**
  * Props for the DialogHeader component (semantic header element)
  * @public
@@ -1008,6 +1008,20 @@ declare const DialogPortal: React$1.FC<DialogPortalProps>;
  * @returns JSX.Element - The semantic dialog content with overlay and optional close button
  */
 declare const DialogContent: React$1.ForwardRefExoticComponent<DialogContentProps & React$1.RefAttributes<HTMLDialogElement>>;
+/**
+ * Props for the DialogClose component
+ * @public
+ */
+interface DialogCloseProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+/**
+ * Props for the DialogClose component
+ * @public
+ */
+interface DialogCloseProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Whether to merge props with child element instead of rendering a button */
+    asChild?: boolean;
+}
 /**
  * DialogClose component
  * Button to close the dialog
@@ -1073,6 +1087,7 @@ interface SelectProps extends Omit<React$1.HTMLAttributes<HTMLFieldSetElement>,
     children: React$1.ReactNode;
     className?: string;
     direction?: SelectDirection;
+    showCheckmark?: boolean;
 }
 /**
  * Props for the SelectTrigger component.
@@ -1108,6 +1123,7 @@ interface SelectItemProps {
     disabled?: boolean;
     className?: string;
     onClick?: (e: React$1.MouseEvent) => void;
+    showCheckmark?: boolean;
 }
 
 /**
@@ -1171,39 +1187,39 @@ declare const SelectContent: React$1.ForwardRefExoticComponent<SelectContentProp
 declare const SelectItem: React$1.ForwardRefExoticComponent<SelectItemProps & React$1.RefAttributes<HTMLLIElement>>;
 /**
  * Select group component.
- * Groups related select items together.
+ * Groups related select items together using a nested list structure.
  *
  * @param props - Select group configuration
- * @param ref - Forwarded ref to the div element
+ * @param ref - Forwarded ref to the ul element
  * @returns The rendered select group
  */
 declare const SelectGroup: React$1.ForwardRefExoticComponent<{
     children: React$1.ReactNode;
     className?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
+} & React$1.RefAttributes<HTMLUListElement>>;
 /**
  * Select label component.
  * Provides a label for a group of select items.
  *
  * @param props - Select label configuration
- * @param ref - Forwarded ref to the div element
+ * @param ref - Forwarded ref to the li element
  * @returns The rendered select label
  */
 declare const SelectLabel: React$1.ForwardRefExoticComponent<{
     children: React$1.ReactNode;
     className?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
+} & React$1.RefAttributes<HTMLLIElement>>;
 /**
  * Select separator component.
  * Provides visual separation between groups of select items.
  *
  * @param props - Select separator configuration
- * @param ref - Forwarded ref to the div element
+ * @param ref - Forwarded ref to the hr element
  * @returns The rendered select separator
  */
 declare const SelectSeparator: React$1.ForwardRefExoticComponent<{
     className?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
+} & React$1.RefAttributes<HTMLHRElement>>;
 
 /**
  * @file Tabs Component System

package/dist/{UnifiedAuthProvider-ZT6TIGM7.js → UnifiedAuthProvider-7SNDOWYD.js}

@@ -1,5 +1,5 @@
-export { UnifiedAuthContext, UnifiedAuthProvider, useUnifiedAuth } from './chunk-FTCRZOG2.js';
-import './chunk-ZFYPMX46.js';
+export { UnifiedAuthContext, UnifiedAuthProvider, useUnifiedAuth } from './chunk-T5CVK4R3.js';
+import './chunk-LX6U42O3.js';
 import './chunk-AHU7G2R5.js';
 import './chunk-4SXLQIZO.js';
 import './chunk-HF6O3O37.js';

package/dist/{api-Y4MQWOFW.js → api-7P7DI652.js}

@@ -1,4 +1,4 @@
-export { OrganisationContextRequiredError, clearCache, getAccessLevel, getPageScopeType, getPermissionMap, getRoleContext, hasAllPermissions, hasAnyPermission, invalidateAppCache, invalidateEventCache, invalidateOrganisationCache, invalidateUserCache, isEventAdmin, isOrganisationAdmin, isPermitted, isPermittedCached, isRBACInitialized, isSuperAdmin, resolveAppContext, setupRBAC } from './chunk-ZFYPMX46.js';
+export { OrganisationContextRequiredError, clearCache, getAccessLevel, getPageScopeType, getPermissionMap, getRoleContext, hasAllPermissions, hasAnyPermission, invalidateAppCache, invalidateEventCache, invalidateOrganisationCache, invalidateUserCache, isEventAdmin, isOrganisationAdmin, isPermitted, isPermittedCached, isRBACInitialized, isSuperAdmin, resolveAppContext, setupRBAC } from './chunk-LX6U42O3.js';
 import './chunk-AHU7G2R5.js';
 import './chunk-TTRFSOKR.js';
 import './chunk-3RG5ZIWI.js';

package/dist/{chunk-MAGBIDNS.js → chunk-4DDCYDQ3.js}

@@ -1,6 +1,6 @@
-import { generateFilePath, generateUniqueFileName, extractFileMetadata, uploadFile, getPublicUrl, getSignedUrl, deleteFile, downloadFile, listFiles, archiveFile } from './chunk-FENMYN2U.js';
-import { useOrganisationSecurity, usePublicPageContext } from './chunk-3O3WHILE.js';
-import { useOrganisations } from './chunk-FTCRZOG2.js';
+import { generateFilePath, generateUniqueFileName, extractFileMetadata, uploadFile, getPublicUrl, getSignedUrl, deleteFile, downloadFile, listFiles, archiveFile } from './chunk-MPBLMWVR.js';
+import { useOrganisationSecurity, usePublicPageContext } from './chunk-EF2UGZWY.js';
+import { useOrganisations } from './chunk-T5CVK4R3.js';
 import { assertOrganisationId } from './chunk-4SXLQIZO.js';
 import { createLogger, logger } from './chunk-TTRFSOKR.js';
 import { useForm } from 'react-hook-form';
@@ -481,13 +481,14 @@ function usePublicRouteParams(options = {}) {
   }, [fetchEventData, eventLoading]);
   const finalError = useMemo(() => {
     if (error) return error;
-    if (eventError) return eventError;
+    if (!validateEventCode) return null;
+    if (fetchEventData && eventError) return eventError;
     return null;
-  }, [error, eventError]);
+  }, [error, eventError, fetchEventData, validateEventCode]);
   const eventId = useMemo(() => {
-    if (!event) return null;
+    if (!fetchEventData || !event) return null;
     return event.event_id || event.id;
-  }, [event]);
+  }, [fetchEventData, event]);
   const refetch = useCallback(async () => {
     if (!fetchEventData) return;
     await refetchEvent();

package/dist/{chunk-BVP2BCJF.js → chunk-5W2A3DRC.js}

@@ -1,7 +1,6 @@
 import { createLogger } from './chunk-TTRFSOKR.js';
 
 // src/theming/parseEventColours.ts
-var log = createLogger("ParseEventColours");
 function parseAndNormalizeEventColours(input) {
   try {
     if (!input) return null;
@@ -15,17 +14,20 @@ function parseAndNormalizeEventColours(input) {
     } else if (typeof input !== "object") {
       return null;
     }
-    const main = obj?.main || null;
-    const sec = obj?.sec || null;
-    const acc = obj?.acc || null;
-    if (!main && !sec && !acc) return null;
+    const main = obj?.main || obj?.["ev-main"] || null;
+    const sec = obj?.sec || obj?.["ev-sec"] || null;
+    const acc = obj?.acc || obj?.["ev-acc"] || null;
+    if (!main && !sec && !acc) {
+      return null;
+    }
     const fill = (p) => {
       if (!p || typeof p !== "object") return {};
       const out = {};
       for (const key in p) {
         const value = p[key];
         if (value !== null && value !== void 0 && value !== "") {
-          out[key] = value;
+          const normalizedKey = typeof key === "string" && key.startsWith("ev-") ? key.substring(3) : key;
+          out[normalizedKey] = value;
         }
       }
       return out;
@@ -36,19 +38,18 @@ function parseAndNormalizeEventColours(input) {
       acc: fill(acc)
     };
   } catch (error) {
-    log.warn("Failed to parse/normalize event colours:", error);
     return null;
   }
 }
 
 // src/theming/runtime.ts
-var log2 = createLogger("ThemingRuntime");
+var log = createLogger("ThemingRuntime");
 function formatOklchCss(color) {
   return `oklch(${color.L} ${color.C} ${color.H})`;
 }
 function applyPalette(palette) {
   if (typeof document === "undefined" || document === null) {
-    log2.warn("Document not available (SSR) - palette not applied");
+    log.warn("Document not available (SSR) - palette not applied");
     return;
   }
   const root = document.documentElement;

package/dist/{chunk-SD6WQY43.js → chunk-7ILTDCL2.js}

@@ -1,3 +1,11 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+// src/utils/core/cn.ts
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
 // src/utils/performance/performanceBudgets.ts
 var PERFORMANCE_BUDGETS = {
   COMPONENT_RENDER: { threshold: 50 },
@@ -69,4 +77,4 @@ performanceBudgetMonitor.setBudget("CHUNK_COUNT", 10, "warning");
 performanceBudgetMonitor.setBudget("TREESHAKING_SCORE", 70, "warning");
 performanceBudgetMonitor.setBudget("ERROR_BOUNDARY_TRIGGER", 5, "error");
 
-export { PERFORMANCE_BUDGETS, performanceBudgetMonitor };
+export { PERFORMANCE_BUDGETS, cn, performanceBudgetMonitor };