@jmruthers/pace-core 0.6.6 → 0.6.7

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-7PMH7XN7.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-Q7Q7V5NV.js';
+import './chunk-BM4CQ5P3.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-VBCS3DUA.js';
+import './chunk-C7NSAPTL.js';
+import './chunk-FTCRZOG2.js';
+import './chunk-ZFYPMX46.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-DlsCaR5v.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';
@@ -912,9 +912,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 +926,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 +1002,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 +1081,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 +1117,7 @@ interface SelectItemProps {
     disabled?: boolean;
     className?: string;
     onClick?: (e: React$1.MouseEvent) => void;
+    showCheckmark?: boolean;
 }
 
 /**
@@ -1171,39 +1181,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/{chunk-FENMYN2U.js → chunk-5X4QLXRG.js}

@@ -1,4 +1,4 @@
-import { clearPalette, parseAndNormalizeEventColours, applyPalette } from './chunk-BVP2BCJF.js';
+import { clearPalette, parseAndNormalizeEventColours, applyPalette } from './chunk-ZKAWKYT4.js';
 import { EventServiceContext } from './chunk-FTCRZOG2.js';
 import { assertAppId } from './chunk-4SXLQIZO.js';
 import { fetchPlaceDetails, createAddressFromPlaceResult, getAddressByPlaceId, fetchPlaceAutocomplete, setOrganisationContext } from './chunk-FYHN4DD5.js';
@@ -2087,7 +2087,6 @@ function invalidateFileDisplayCache(table_name, record_id, organisation_id, cate
     authenticatedFileCache.delete(allCategoryKey);
   }
 }
-var log4 = createLogger("useEventTheme");
 function useEventTheme(event) {
   const location = useLocation();
   const eventServiceContext = useContext(EventServiceContext);
@@ -2112,7 +2111,6 @@ function useEventTheme(event) {
     try {
       applyPalette(normalized);
     } catch (error) {
-      log4.error("Failed to apply event palette:", error);
     }
     return () => {
     };

package/dist/{chunk-4T7OBVTU.js → chunk-6F3IILHI.js}

@@ -1,4 +1,4 @@
-import { Button } from './chunk-7TYHROIV.js';
+import { Button } from './chunk-BM4CQ5P3.js';
 import { ShieldX } from 'lucide-react';
 import { jsx, jsxs } from 'react/jsx-runtime';
 

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 };

package/dist/{chunk-3QC3KRHK.js → chunk-A3W6LW53.js}

@@ -1,3 +1,5 @@
+import { jsx } from 'react/jsx-runtime';
+
 // src/utils/validation/htmlSanitization.ts
 function sanitizeHtml(html) {
   if (!html || typeof html !== "string") {
@@ -51,5 +53,18 @@ function renderSafeHtml(html, options = {}) {
     warnings: validation.warnings
   };
 }
+var LoadingSpinner = ({
+  size = "md",
+  className = ""
+}) => {
+  const sizeClasses = {
+    sm: "size-4",
+    md: "size-6",
+    lg: "size-8"
+  };
+  const validSize = size && size in sizeClasses ? size : "md";
+  const sizeClass = sizeClasses[validSize];
+  return /* @__PURE__ */ jsx("canvas", { className: `inline-block animate-spin rounded-full border-2 border-solid border-current border-r-transparent motion-reduce:animate-[spin_1.5s_linear_infinite] ${sizeClass} ${className}`.trim(), role: "status", children: /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Loading..." }) });
+};
 
-export { renderSafeHtml, sanitizeHtml, validateHtml };
+export { LoadingSpinner, renderSafeHtml, sanitizeHtml, validateHtml };

package/dist/{chunk-7TYHROIV.js → chunk-BM4CQ5P3.js}

@@ -1,9 +1,10 @@
-import { useAppConfig, useOrganisationSecurity } from './chunk-3O3WHILE.js';
+import { useAppConfig, useOrganisationSecurity } from './chunk-VBCS3DUA.js';
 import { useEventService, useUnifiedAuth, useOrganisations } from './chunk-FTCRZOG2.js';
 import { OrganisationContextRequiredError, getRBACLogger, resolveAppContext, getPageScopeType, ContextValidator, getPermissionMap, getRoleContext, getAccessLevel, isPermittedCached, isPermitted, isSuperAdmin } from './chunk-ZFYPMX46.js';
-import { cn, getCurrentAppName } from './chunk-A55DK444.js';
+import { getCurrentAppName } from './chunk-OJ4SKRSV.js';
+import { cn } from './chunk-7ILTDCL2.js';
 import { createLogger, logger } from './chunk-TTRFSOKR.js';
-import * as React from 'react';
+import * as React2 from 'react';
 import { useRef, useMemo, useState, useCallback, useEffect } from 'react';
 import * as TooltipPrimitive from '@radix-ui/react-tooltip';
 import { jsx, jsxs } from 'react/jsx-runtime';
@@ -52,7 +53,7 @@ function useEvents() {
 var TooltipProvider = TooltipPrimitive.Provider;
 var TooltipRoot = TooltipPrimitive.Root;
 var TooltipTrigger = TooltipPrimitive.Trigger;
-var TooltipContent = React.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(
+var TooltipContent = React2.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(
   TooltipPrimitive.Content,
   {
     ref,
@@ -65,7 +66,7 @@ var TooltipContent = React.forwardRef(({ className, sideOffset = 4, ...props },
   }
 ));
 TooltipContent.displayName = TooltipPrimitive.Content.displayName;
-var Tooltip = React.forwardRef(({ children, content, delayDuration = 200 }, ref) => /* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(TooltipRoot, { delayDuration, children: [
+var Tooltip = React2.forwardRef(({ children, content, delayDuration = 200 }, ref) => /* @__PURE__ */ jsx(TooltipProvider, { children: /* @__PURE__ */ jsxs(TooltipRoot, { delayDuration, children: [
   /* @__PURE__ */ jsx(TooltipTrigger, { ref, asChild: true, children: /* @__PURE__ */ jsx("span", { children }) }),
   /* @__PURE__ */ jsx(TooltipContent, { children: content })
 ] }) }));
@@ -88,7 +89,7 @@ function getButtonClasses(variant = "default", size = "default") {
   };
   return `${baseClasses} ${variantClasses[variant]} ${sizeClasses[size]}`;
 }
-var Button = React.forwardRef(
+var Button = React2.forwardRef(
   ({ className, variant, size, asChild = false, type = "button", disabled, ...props }, ref) => {
     const Comp = asChild ? Slot : "button";
     return /* @__PURE__ */ jsx(
@@ -105,7 +106,48 @@ var Button = React.forwardRef(
   }
 );
 Button.displayName = "Button";
-var IconButton = React.forwardRef(
+function ButtonGroup({
+  children,
+  orientation = "horizontal",
+  variant,
+  size,
+  className,
+  spacing = "sm"
+}) {
+  const spacingClasses = {
+    none: "",
+    sm: orientation === "horizontal" ? "space-x-1" : "space-y-1",
+    md: orientation === "horizontal" ? "space-x-2" : "space-y-2",
+    lg: orientation === "horizontal" ? "space-x-4" : "space-y-4"
+  };
+  return /* @__PURE__ */ jsx(
+    "fieldset",
+    {
+      className: cn(
+        "flex",
+        orientation === "horizontal" ? "flex-row items-center" : "flex-col",
+        spacingClasses[spacing],
+        className
+      ),
+      role: "group",
+      children: React2.Children.map(children, (child) => {
+        if (React2.isValidElement(child) && child.type) {
+          const componentType = child.type;
+          if (componentType.displayName === "Button") {
+            const childProps = child.props;
+            return React2.cloneElement(child, {
+              variant: childProps.variant || variant,
+              size: childProps.size || size,
+              ...childProps
+            });
+          }
+        }
+        return child;
+      })
+    }
+  );
+}
+var IconButton = React2.forwardRef(
   ({ icon, className, size = "icon", "aria-label": ariaLabel, tooltip, ...props }, ref) => {
     const button = /* @__PURE__ */ jsx(
       Button,
@@ -1958,4 +2000,4 @@ function useSecureSupabase(baseClient) {
   ]);
 }
 
-export { Button, SECURE_CLIENT_SYMBOL, SecureSupabaseClient, Tooltip, TooltipContent, TooltipProvider, TooltipRoot, TooltipTrigger, createSecureClient, fromSupabaseClient, isSecureClient, scopeEqual, useAccessLevel, useCan, useEvents, useMultiplePermissions, usePermissions, useRBAC, useResolvedScope, useResourcePermissions, useRoleManagement, useSecureSupabase, warnIfInsecureClient };
+export { Button, ButtonGroup, SECURE_CLIENT_SYMBOL, SecureSupabaseClient, Tooltip, TooltipContent, TooltipProvider, TooltipRoot, TooltipTrigger, createSecureClient, fromSupabaseClient, isSecureClient, scopeEqual, useAccessLevel, useCan, useEvents, useMultiplePermissions, usePermissions, useRBAC, useResolvedScope, useResourcePermissions, useRoleManagement, useSecureSupabase, warnIfInsecureClient };