@elevasis/ui 1.15.3 → 1.17.0

package/dist/api/hooks/__tests__/useApiClient.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Unit tests for useApiClient - API request timeout behavior
+ *
+ * Tests:
+ * 1. Successful requests complete normally with timeout signal attached
+ * 2. Requests abort after 30s timeout
+ * 3. Caller-provided signal is merged with timeout signal
+ * 4. Unauthenticated fallback path also has timeout
+ */
+export {};
+//# sourceMappingURL=useApiClient.test.d.ts.map

package/dist/api/hooks/__tests__/useApiClient.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApiClient.test.d.ts","sourceRoot":"","sources":["../../../../src/api/hooks/__tests__/useApiClient.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/api/hooks/useApiClient.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Hook that returns apiRequest and deferredApiRequest bound to the current
+ * ApiClientContext. apiUrl is the only parameter because org ID is resolved
+ * at call time via getOrganizationId() from context.
+ *
+ * When OrganizationProvider is present in the tree, isOrganizationReady and
+ * isInitializing reflect the live org state (currentWorkOSOrganizationId,
+ * isInitializing, isOrgRefreshing). When OrganizationProvider is absent
+ * (e.g. theme-only mode, testing), the hook falls back to the values from
+ * ApiClientContext.
+ *
+ * Usage:
+ * ```typescript
+ * import { useApiClient } from '@repo/ui/api'
+ * import { API_URL } from '@/lib/constants/api'
+ *
+ * function useMyClient() {
+ *   return useApiClient(API_URL)
+ * }
+ * ```
+ */
+export declare function useApiClient(apiUrl: string): {
+    apiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+    deferredApiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+    isOrganizationReady: boolean;
+    isInitializing: boolean;
+};
+//# sourceMappingURL=useApiClient.d.ts.map

package/dist/api/hooks/useApiClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApiClient.d.ts","sourceRoot":"","sources":["../../../src/api/hooks/useApiClient.ts"],"names":[],"mappings":"AAiGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;iBAsCtC,CAAC,YAAY,MAAM,YAAW,WAAW,KAAQ,OAAO,CAAC,CAAC,CAAC;yBAMrD,CAAC,YAAY,MAAM,YAAW,WAAW,KAAQ,OAAO,CAAC,CAAC,CAAC;;;EAkBrE"}

package/dist/api/index.d.ts

@@ -1,100 +1,20 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-
 /**
- * API module types
- */
-interface ApiClientContextValue {
-    getAccessToken: () => Promise<string | undefined>;
-    /** @deprecated Read via getOrganizationId() instead. Kept for downstream context consumers during migration. */
-    organizationId: string | null;
-    isOrganizationReady: boolean;
-    getOrganizationId: () => string | null;
-    onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
-}
-interface ApiErrorDetails {
-    method: string;
-    statusCode: number;
-    requestId?: string;
-}
-interface ApiClientProviderProps {
-    children: React.ReactNode;
-    getAccessToken: () => Promise<string | undefined>;
-    /**
-     * Static org ID. Used when org ID is stable at render time.
-     * Cannot reflect org switches without re-rendering the provider.
-     * Prefer getOrganizationId for dynamic org context.
-     * @deprecated Pass getOrganizationId instead for dynamic org resolution.
-     */
-    organizationId?: string | null;
-    /**
-     * Callback invoked on every request to read the current org ID.
-     * Takes precedence over organizationId when provided.
-     * Allows org switching without re-rendering the provider tree.
-     */
-    getOrganizationId?: () => string | null;
-    isOrganizationReady: boolean;
-    onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
-}
-
-/**
- * Hook to access the API client context
- * Must be used within an ApiClientProvider
- */
-declare function useApiClientContext(): ApiClientContextValue;
-/**
- * Provider component that configures the API client context
- *
- * Configure this at your app root with auth and organization dependencies.
- * All components using useApiClient will automatically get the configured values.
- *
- * @example
- * ```tsx
- * function App() {
- *   const { getAccessToken } = useAuth()
- *   const { currentWorkOSOrganizationId, currentMembership } = useOrganizations()
- *
- *   return (
- *     <ApiClientProvider
- *       getAccessToken={getAccessToken}
- *       organizationId={currentWorkOSOrganizationId}
- *       isOrganizationReady={!!currentMembership}
- *       onError={(endpoint, error, details) => logError(endpoint, error, details)}
- *     >
- *       <YourApp />
- *     </ApiClientProvider>
- *   )
- * }
- * ```
- */
-declare function ApiClientProvider({ children, getAccessToken, organizationId, getOrganizationId: getOrganizationIdProp, isOrganizationReady, onError }: ApiClientProviderProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Hook that returns apiRequest and deferredApiRequest bound to the current
- * ApiClientContext. apiUrl is the only parameter because org ID is resolved
- * at call time via getOrganizationId() from context.
+ * API module - HTTP client with Provider pattern
  *
- * When OrganizationProvider is present in the tree, isOrganizationReady and
- * isInitializing reflect the live org state (currentWorkOSOrganizationId,
- * isInitializing, isOrgRefreshing). When OrganizationProvider is absent
- * (e.g. theme-only mode, testing), the hook falls back to the values from
- * ApiClientContext.
+ * Exports:
+ * - ApiClientProvider: Configure API client at app root
+ * - useApiClientContext: Hook to access API client context directly
+ * - useApiClient: Org-aware hook that reads OrganizationContext for readiness
+ * - Types for API client configuration
  *
  * Usage:
  * ```typescript
  * import { useApiClient } from '@repo/ui/api'
- * import { API_URL } from '@/lib/constants/api'
  *
- * function useMyClient() {
- *   return useApiClient(API_URL)
- * }
+ * const { apiRequest, isOrganizationReady } = useApiClient(API_URL)
  * ```
  */
-declare function useApiClient(apiUrl: string): {
-    apiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
-    deferredApiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
-    isOrganizationReady: boolean;
-    isInitializing: boolean;
-};
-
-export { ApiClientProvider, useApiClient, useApiClientContext };
-export type { ApiClientContextValue, ApiClientProviderProps, ApiErrorDetails };
+export { ApiClientProvider, useApiClientContext } from './context/ApiClientProvider';
+export { useApiClient } from './hooks/useApiClient';
+export type { ApiClientContextValue, ApiClientProviderProps, ApiErrorDetails } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AAGpF,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAGnD,YAAY,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA"}

package/dist/auth/guards/AdminGuard.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode } from 'react';
+export interface AdminGuardProps {
+    children: ReactNode;
+    /**
+     * Path to redirect non-admin users to.
+     * @default '/'
+     */
+    redirectTo?: string;
+    /**
+     * Rendered while user readiness is being determined.
+     * When not provided, nothing is rendered during initialization.
+     */
+    fallback?: ReactNode;
+}
+/**
+ * Headless route guard for platform admin pages.
+ *
+ * Reads `profile.is_platform_admin` from the nearest InitializationProvider.
+ * Non-admin users are redirected to `redirectTo` (default: '/').
+ *
+ * Must be nested inside a ProtectedRoute (or equivalent) so that
+ * `userReady` is guaranteed to be true when this guard runs.
+ *
+ * @example
+ * <ProtectedRoute>
+ *   <AdminGuard fallback={<AppShellLoader />}>
+ *     <AdminDashboard />
+ *   </AdminGuard>
+ * </ProtectedRoute>
+ */
+export declare function AdminGuard({ children, redirectTo, fallback }: AdminGuardProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=AdminGuard.d.ts.map

package/dist/auth/guards/AdminGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdminGuard.d.ts","sourceRoot":"","sources":["../../../src/auth/guards/AdminGuard.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAIjD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,SAAS,CAAA;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,EAAE,QAAQ,EAAE,UAAgB,EAAE,QAAe,EAAE,EAAE,eAAe,kDA0B1F"}

package/dist/auth/guards/ProtectedRoute.d.ts

@@ -0,0 +1,60 @@
+import { type ReactNode } from 'react';
+import type { InitializationError } from '../../initialization/hooks/useAppInitialization';
+export interface ProtectedRouteProps {
+    children: ReactNode;
+    /**
+     * Path to redirect to when user is unauthenticated and the auth adapter
+     * does not provide a `signIn` function.
+     * @default '/login'
+     */
+    redirectTo?: string;
+    /**
+     * Rendered while initialization is in progress.
+     * When not provided, nothing is rendered during initialization.
+     */
+    fallback?: ReactNode;
+    /**
+     * Rendered when initialization fails with a non-organization error.
+     * Receives the error and a retry callback.
+     * When not provided, the error is silently swallowed (children not rendered).
+     */
+    errorFallback?: (error: InitializationError, retry: () => void) => ReactNode;
+    /**
+     * When true (default), waits for both user AND organization to be ready
+     * before rendering children. When false, only waits for user readiness.
+     * @default true
+     */
+    waitForOrganization?: boolean;
+}
+/**
+ * Headless route guard for authenticated pages.
+ *
+ * Reads initialization state from the nearest InitializationProvider.
+ *
+ * When `canRecover()` returns true (refresh token exists), unauthenticated users
+ * are sent directly to WorkOS AuthKit via `signIn()`. WorkOS checks its
+ * server-side session and either signs the user in immediately (page-reload case)
+ * or shows a login form (logged-out case). Explicit logout destroys the
+ * server-side session, so the next auto-signIn correctly presents a login form
+ * rather than looping.
+ *
+ * When `canRecover()` returns false, falls back to navigating to `redirectTo`
+ * (default: '/login') with a `returnTo` search param.
+ *
+ * Organization-layer errors are allowed through -- routes like /invitations
+ * must be accessible even when the user has no org membership.
+ *
+ * @example
+ * // With custom fallback (your Mantine loader):
+ * <ProtectedRoute fallback={<AppShellLoader />}>
+ *   <DashboardPage />
+ * </ProtectedRoute>
+ *
+ * @example
+ * // Wait only for user, not org (e.g. /invitations route):
+ * <ProtectedRoute waitForOrganization={false}>
+ *   <InvitationsPage />
+ * </ProtectedRoute>
+ */
+export declare function ProtectedRoute({ children, redirectTo, fallback, errorFallback, waitForOrganization }: ProtectedRouteProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=ProtectedRoute.d.ts.map

package/dist/auth/guards/ProtectedRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtectedRoute.d.ts","sourceRoot":"","sources":["../../../src/auth/guards/ProtectedRoute.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAIzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAA;AAE1F,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,SAAS,CAAA;IACnB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,SAAS,CAAA;IAC5E;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,UAAqB,EACrB,QAAe,EACf,aAAa,EACb,mBAA0B,EAC3B,EAAE,mBAAmB,kDAyDrB"}

package/dist/auth/guards/__tests__/AdminGuard.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AdminGuard Tests (shared @repo/ui guard)
+ *
+ * Tests role-based access control for platform admin pages:
+ * - Shows fallback while user is not ready
+ * - Renders children for platform admin users
+ * - Redirects non-admin users to redirectTo (default: '/')
+ * - Handles missing profile gracefully
+ * - Supports custom redirectTo
+ */
+export {};
+//# sourceMappingURL=AdminGuard.test.d.ts.map

package/dist/auth/guards/__tests__/AdminGuard.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdminGuard.test.d.ts","sourceRoot":"","sources":["../../../../src/auth/guards/__tests__/AdminGuard.test.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/auth/guards/__tests__/ProtectedRoute.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ProtectedRoute Tests (shared @repo/ui guard)
+ *
+ * Tests headless authentication guard behavior:
+ * - Shows fallback while initializing
+ * - Redirects unauthenticated users to login with returnTo
+ * - Renders children when user is ready
+ * - Renders children when org error (allows /invitations route pattern)
+ * - Shows errorFallback for non-organization errors
+ * - Waits for org readiness when waitForOrganization=true (default)
+ * - Renders after user ready when waitForOrganization=false
+ */
+export {};
+//# sourceMappingURL=ProtectedRoute.test.d.ts.map

package/dist/auth/guards/__tests__/ProtectedRoute.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtectedRoute.test.d.ts","sourceRoot":"","sources":["../../../../src/auth/guards/__tests__/ProtectedRoute.test.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/auth/index.d.ts

@@ -1,176 +1,16 @@
-import * as react from 'react';
-import { ReactNode } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-
-interface AuthContextValue {
-    user: {
-        id: string;
-    } | null;
-    isLoading: boolean;
-    getAccessToken: () => Promise<string>;
-    organizationId?: string | null;
-    /**
-     * Trigger WorkOS AuthKit's sign-in flow (redirect to WorkOS hosted auth page).
-     * Used by ProtectedRoute for auto-recovery when `canRecover()` returns true.
-     */
-    signIn: (options?: {
-        state?: {
-            returnTo?: string;
-        };
-    }) => void;
-    /**
-     * Returns true when a previous session can be recovered (refresh token
-     * exists in storage). ProtectedRoute calls `signIn()` only when this returns
-     * true; otherwise it navigates to the login page.
-     *
-     * Explicit logout clears the stored token, so canRecover() returns false
-     * and the user sees the login page as expected.
-     */
-    canRecover: () => boolean;
-}
-declare function useAuthContext(): AuthContextValue;
-declare function AuthProvider({ value, children }: {
-    value: AuthContextValue;
-    children: ReactNode;
-}): react.FunctionComponentElement<react.ProviderProps<AuthContextValue | null>>;
-
 /**
- * Returns a stable reference to getAccessToken that won't change between renders
- *
- * This prevents SSE connections from reconnecting unnecessarily when the
- * WorkOS useAuth hook returns a new getAccessToken function reference
- *
- * @example
- * ```tsx
- * const getAccessToken = useStableAccessToken()
- *
- * useEffect(() => {
- *   fetchEventSourceWithTokenRefresh({
- *     getToken: getAccessToken,
- *     // ...
- *   })
- * }, [getAccessToken]) // Won't re-run on every render
- * ```
- */
-declare function useStableAccessToken(): () => Promise<string>;
-
-/**
- * Checks WorkOS session validity when window/tab regains focus
- *
- * When window or tab becomes visible after inactivity, validates session
- * by attempting to get access token. If session expired (WorkOS inactivity
- * timeout exceeded), signs out user and redirects to login.
- *
- * How it works:
- * 1. Window/tab regains focus after inactivity
- * 2. Cancel all pending queries to prevent 401 error cascade
- * 3. Attempt to get access token from WorkOS
- * 4. If successful: Resume queries with fresh token
- * 5. If failed (session expired): Sign out and redirect to login
- *
- * @example
- * // In __root.tsx
- * export function RootLayoutComponent() {
- *   useSessionCheck()
- *   return <YourApp />
- * }
- */
-declare function useSessionCheck(): void;
-
-interface InitializationError {
-    layer: 'auth' | 'profile' | 'organization';
-    message: string;
-    originalError?: Error;
-}
-
-interface ProtectedRouteProps {
-    children: ReactNode;
-    /**
-     * Path to redirect to when user is unauthenticated and the auth adapter
-     * does not provide a `signIn` function.
-     * @default '/login'
-     */
-    redirectTo?: string;
-    /**
-     * Rendered while initialization is in progress.
-     * When not provided, nothing is rendered during initialization.
-     */
-    fallback?: ReactNode;
-    /**
-     * Rendered when initialization fails with a non-organization error.
-     * Receives the error and a retry callback.
-     * When not provided, the error is silently swallowed (children not rendered).
-     */
-    errorFallback?: (error: InitializationError, retry: () => void) => ReactNode;
-    /**
-     * When true (default), waits for both user AND organization to be ready
-     * before rendering children. When false, only waits for user readiness.
-     * @default true
-     */
-    waitForOrganization?: boolean;
-}
-/**
- * Headless route guard for authenticated pages.
- *
- * Reads initialization state from the nearest InitializationProvider.
- *
- * When `canRecover()` returns true (refresh token exists), unauthenticated users
- * are sent directly to WorkOS AuthKit via `signIn()`. WorkOS checks its
- * server-side session and either signs the user in immediately (page-reload case)
- * or shows a login form (logged-out case). Explicit logout destroys the
- * server-side session, so the next auto-signIn correctly presents a login form
- * rather than looping.
- *
- * When `canRecover()` returns false, falls back to navigating to `redirectTo`
- * (default: '/login') with a `returnTo` search param.
- *
- * Organization-layer errors are allowed through -- routes like /invitations
- * must be accessible even when the user has no org membership.
- *
- * @example
- * // With custom fallback (your Mantine loader):
- * <ProtectedRoute fallback={<AppShellLoader />}>
- *   <DashboardPage />
- * </ProtectedRoute>
- *
- * @example
- * // Wait only for user, not org (e.g. /invitations route):
- * <ProtectedRoute waitForOrganization={false}>
- *   <InvitationsPage />
- * </ProtectedRoute>
- */
-declare function ProtectedRoute({ children, redirectTo, fallback, errorFallback, waitForOrganization }: ProtectedRouteProps): react_jsx_runtime.JSX.Element | null;
-
-interface AdminGuardProps {
-    children: ReactNode;
-    /**
-     * Path to redirect non-admin users to.
-     * @default '/'
-     */
-    redirectTo?: string;
-    /**
-     * Rendered while user readiness is being determined.
-     * When not provided, nothing is rendered during initialization.
-     */
-    fallback?: ReactNode;
-}
-/**
- * Headless route guard for platform admin pages.
- *
- * Reads `profile.is_platform_admin` from the nearest InitializationProvider.
- * Non-admin users are redirected to `redirectTo` (default: '/').
- *
- * Must be nested inside a ProtectedRoute (or equivalent) so that
- * `userReady` is guaranteed to be true when this guard runs.
- *
- * @example
- * <ProtectedRoute>
- *   <AdminGuard fallback={<AppShellLoader />}>
- *     <AdminDashboard />
- *   </AdminGuard>
- * </ProtectedRoute>
+ * Auth module - Pure authentication concerns
+ *
+ * Exports:
+ * - AuthContextValue: Interface for auth state (user, isLoading, getAccessToken, organizationId, signIn, canRecover)
+ * - AuthProvider: React context provider for AuthContextValue
+ * - useAuthContext: Hook to consume AuthContextValue from context
+ * - useStableAccessToken: Stable reference to getAccessToken for SSE connections
+ * - useSessionCheck: Validates session on tab refocus
  */
-declare function AdminGuard({ children, redirectTo, fallback }: AdminGuardProps): react_jsx_runtime.JSX.Element | null;
-
-export { AdminGuard, AuthProvider, ProtectedRoute, useAuthContext, useSessionCheck as useRefocusSessionCheck, useSessionCheck, useStableAccessToken };
-export type { AdminGuardProps, AuthContextValue, ProtectedRouteProps };
+export { AuthProvider, useAuthContext, type AuthContextValue } from './context';
+export * from './hooks/useStableAccessToken';
+export * from './hooks/useSessionCheck';
+export { ProtectedRoute, type ProtectedRouteProps } from './guards/ProtectedRoute';
+export { AdminGuard, type AdminGuardProps } from './guards/AdminGuard';
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAC/E,cAAc,8BAA8B,CAAA;AAC5C,cAAc,yBAAyB,CAAA;AACvC,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAClF,OAAO,EAAE,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/charts/index.d.ts

@@ -1,6 +1,29 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
 
+/**
+ * ChartFrame decouples chart width from live parent width changes by debouncing
+ * ResizeObserver callbacks. Prevents Recharts (under @mantine/charts) from firing
+ * dozens of full re-renders during the sidebar collapse/expand animation.
+ *
+ * How it works: the outer div observes its real container width. The inner div
+ * is given a fixed pixel width from React state, which Recharts' own
+ * ResponsiveContainer reads. State only updates after `debounceMs` of quiet, so
+ * the chart doesn't re-render on every frame of the sidebar transition.
+ *
+ * @repo/ui context: used wherever a @mantine/charts component renders inside
+ * a layout that has a CSS-transitioned collapsible sidebar. Without this wrapper,
+ * every frame of the sidebar animation fires ResizeObserver → Recharts scale
+ * recomputation → React reconciliation → SVG regeneration, saturating the main
+ * thread and causing animation jitter.
+ */
+interface ChartFrameProps {
+    h: number;
+    debounceMs?: number;
+    children: ReactNode;
+}
+declare function ChartFrame({ h, debounceMs, children }: ChartFrameProps): react_jsx_runtime.JSX.Element;
+
 /**
  * CyberAreaChart — Reusable area chart with cyber/high-tech aesthetic.
  *
@@ -307,5 +330,5 @@ interface CombinedTrendChartProps {
 }
 declare function CombinedTrendChart({ healthData, errorData: _errorData, isLoading, error, timeRange, navigationAction }: CombinedTrendChartProps): react_jsx_runtime.JSX.Element;
 
-export { ActivityTrendChart, CombinedTrendChart, CostTrendChart, CyberAreaChart, CyberDonut, CyberDonutTooltip, CyberLegendItem, HeroStatsRow, getSeriesColor, useCyberColors };
-export type { ActivityTrendChartProps, CombinedTrendChartProps, CostTrendChartProps, CyberAreaChartProps, CyberColors, CyberDonutProps, CyberDonutSegment, CyberSeries, HeroStatsRowProps };
+export { ActivityTrendChart, ChartFrame, CombinedTrendChart, CostTrendChart, CyberAreaChart, CyberDonut, CyberDonutTooltip, CyberLegendItem, HeroStatsRow, getSeriesColor, useCyberColors };
+export type { ActivityTrendChartProps, ChartFrameProps, CombinedTrendChartProps, CostTrendChartProps, CyberAreaChartProps, CyberColors, CyberDonutProps, CyberDonutSegment, CyberSeries, HeroStatsRowProps };

package/dist/charts/index.js

@@ -1,7 +1,7 @@
-export { ActivityTrendChart, CombinedTrendChart, CostTrendChart, CyberAreaChart, CyberDonut, CyberDonutTooltip, CyberLegendItem, HeroStatsRow, getSeriesColor, useCyberColors } from '../chunk-4NHYV42S.js';
+export { ActivityTrendChart, ChartFrame, CombinedTrendChart, CostTrendChart, CyberAreaChart, CyberDonut, CyberDonutTooltip, CyberLegendItem, HeroStatsRow, getSeriesColor, useCyberColors } from '../chunk-7S5FS7WW.js';
 import '../chunk-KBLGVZBD.js';
 import '../chunk-LXHZYSMQ.js';
-import '../chunk-LHQTTUL2.js';
+import '../chunk-MHW43EOH.js';
 import '../chunk-ELJIFLCB.js';
 import '../chunk-SZHARWKU.js';
 import '../chunk-FCFLBMVI.js';