@elevasis/ui 1.19.0 → 1.20.0

package/dist/api/index.js

@@ -1,4 +1,4 @@
 import '../chunk-XCYKC6OZ.js';
-export { ApiClientProvider, useApiClient, useApiClientContext } from '../chunk-JNBHUCKW.js';
-import '../chunk-MBZDE6UT.js';
+export { ApiClientProvider, useApiClient, useApiClientContext } from '../chunk-NVOCKXUQ.js';
+import '../chunk-IOKL7BKE.js';
 import '../chunk-DD3CCMCZ.js';

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/auth/index.js

@@ -1,6 +1,6 @@
-export { AdminGuard, ProtectedRoute, useSessionCheck as useRefocusSessionCheck, useSessionCheck } from '../chunk-CC3SDRIF.js';
+export { AdminGuard, ProtectedRoute, useSessionCheck as useRefocusSessionCheck, useSessionCheck } from '../chunk-RWQIFKMJ.js';
 export { useStableAccessToken } from '../chunk-ALA56RGZ.js';
-import '../chunk-DVKEEY5J.js';
-import '../chunk-QEPXAWE2.js';
+import '../chunk-TUXTSEAF.js';
 import '../chunk-DD3CCMCZ.js';
+import '../chunk-QEPXAWE2.js';
 export { AuthProvider, useAuthContext } from '../chunk-BRJ3QZ4E.js';

package/dist/charts/index.css

@@ -91,6 +91,9 @@
   animation: chevronPulse 2s ease-in-out infinite;
   filter: drop-shadow(0 0 1.5px var(--loader-color));
 }
+[data-mantine-color-scheme=light] .chevron {
+  filter: none;
+}
 .c1 {
   animation-delay: 0s;
 }
@@ -110,3 +113,14 @@
     filter: drop-shadow(0 0 3px var(--loader-color));
   }
 }
+[data-mantine-color-scheme=light] .chevron {
+  animation-name: chevronPulseLight;
+}
+@keyframes chevronPulseLight {
+  0%, 100% {
+    opacity: 0.2;
+  }
+  40%, 60% {
+    opacity: 1;
+  }
+}

package/dist/charts/index.js

@@ -1,14 +1,16 @@
-export { ActivityTrendChart, ChartFrame, CombinedTrendChart, CostTrendChart, CyberAreaChart, CyberDonut, CyberDonutTooltip, CyberLegendItem, HeroStatsRow, getSeriesColor, useCyberColors } from '../chunk-LBY7FVFD.js';
-import '../chunk-KBLGVZBD.js';
+export { ActivityTrendChart, ChartFrame, CombinedTrendChart, CostTrendChart, CyberAreaChart, CyberDonut, CyberDonutTooltip, CyberLegendItem, HeroStatsRow, getSeriesColor, useCyberColors } from '../chunk-ERVB3QJQ.js';
+import '../chunk-AWMZCYKH.js';
+import '../chunk-NNKKBSJN.js';
+import '../chunk-QJ2S46NI.js';
 import '../chunk-LXHZYSMQ.js';
 import '../chunk-MHW43EOH.js';
 import '../chunk-ELJIFLCB.js';
 import '../chunk-SZHARWKU.js';
-import '../chunk-MBZDE6UT.js';
-import '../chunk-CC3SDRIF.js';
+import '../chunk-IOKL7BKE.js';
+import '../chunk-RWQIFKMJ.js';
 import '../chunk-ALA56RGZ.js';
-import '../chunk-DVKEEY5J.js';
-import '../chunk-QEPXAWE2.js';
+import '../chunk-TUXTSEAF.js';
 import '../chunk-DD3CCMCZ.js';
+import '../chunk-QEPXAWE2.js';
 import '../chunk-BRJ3QZ4E.js';
 import '../chunk-Q7DJKLEN.js';

package/dist/chunk-4SY4EQSK.js

@@ -0,0 +1,68 @@
+import { useCyberColors, CyberLegendItem, CyberAreaChart } from './chunk-ERVB3QJQ.js';
+import { CardHeader, EmptyState } from './chunk-AWMZCYKH.js';
+import { useResourcesHealth } from './chunk-AQ5MQDSS.js';
+import { getTimeRangeDates, formatBucketTime } from './chunk-LXHZYSMQ.js';
+import { Paper, Center, Loader, Group } from '@mantine/core';
+import { IconActivity, IconChartBar } from '@tabler/icons-react';
+import { useMemo } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+function ResourceHealthPanel({ resourceId, resourceType, timeRange }) {
+  const colors = useCyberColors();
+  const { startDate, endDate } = useMemo(() => getTimeRangeDates(timeRange), [timeRange]);
+  const granularity = ["1h", "24h"].includes(timeRange) ? "hour" : "day";
+  const { data, isLoading } = useResourcesHealth({
+    resources: [{ entityType: resourceType, entityId: resourceId }],
+    startDate,
+    endDate,
+    granularity
+  });
+  const resourceHealth = data?.resources?.[0];
+  const chartData = useMemo(() => {
+    if (!resourceHealth?.trendData) return [];
+    return resourceHealth.trendData.map((point) => ({
+      time: point.time,
+      Success: (point.success || 0) - (point.warning || 0),
+      Warning: point.warning || 0,
+      Failed: point.failure || 0
+    }));
+  }, [resourceHealth?.trendData]);
+  const xTickFormatter = useMemo(() => (value) => formatBucketTime(value, granularity), [granularity]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsx(Paper, { withBorder: true, children: /* @__PURE__ */ jsx(Center, { p: "xl", children: /* @__PURE__ */ jsx(Loader, {}) }) });
+  }
+  const summary = resourceHealth?.summary;
+  return /* @__PURE__ */ jsxs(Paper, { withBorder: true, children: [
+    /* @__PURE__ */ jsx(
+      CardHeader,
+      {
+        icon: /* @__PURE__ */ jsx(IconActivity, { size: 18 }),
+        title: "Execution Health",
+        subtitle: `${summary?.total || 0} executions, ${summary?.successRate?.toFixed(1) || 0}% success rate`
+      }
+    ),
+    chartData.length === 0 ? /* @__PURE__ */ jsx(EmptyState, { icon: IconChartBar, title: "No execution data for this time range" }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(Group, { gap: "lg", justify: "center", mb: "xs", h: 24, align: "center", children: [
+        /* @__PURE__ */ jsx(CyberLegendItem, { color: colors.green, label: "Success" }),
+        /* @__PURE__ */ jsx(CyberLegendItem, { color: colors.yellow, label: "Warning" }),
+        /* @__PURE__ */ jsx(CyberLegendItem, { color: colors.red, label: "Failed" })
+      ] }),
+      /* @__PURE__ */ jsx(
+        CyberAreaChart,
+        {
+          data: chartData,
+          series: [
+            { dataKey: "Success", color: "green", name: "Success" },
+            { dataKey: "Warning", color: "yellow", name: "Warning" },
+            { dataKey: "Failed", color: "red", name: "Failed" }
+          ],
+          height: 200,
+          yDomain: [0, "auto"],
+          xTickFormatter
+        }
+      )
+    ] })
+  ] });
+}
+
+export { ResourceHealthPanel };

package/dist/{chunk-7ATCF6UL.js → chunk-ACD2QA6E.js}

@@ -2,12 +2,18 @@ import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { useComputedColorScheme } from '@mantine/core';
 
 // src/components/layout/backgrounds/PerspectiveGrid.tsx
+var SUBTLE_DEFAULT_GLOW = "color-mix(in srgb, color-mix(in srgb, var(--color-primary) 20%, var(--color-border)) 30%, transparent)";
+var PROMINENT_DEFAULT_GLOW = "color-mix(in srgb, var(--color-primary) 28%, transparent)";
 function PerspectiveGrid({
-  glowColor = "color-mix(in srgb, color-mix(in srgb, var(--color-primary) 20%, var(--color-border)) 30%, transparent)",
+  glowColor: glowColorProp,
   lineColor: lineColorProp,
+  prominentGlow = false,
   className
 }) {
   const lineColor = lineColorProp ?? "color-mix(in srgb, var(--color-border) 50%, transparent)";
+  const glowColor = glowColorProp ?? (prominentGlow ? PROMINENT_DEFAULT_GLOW : SUBTLE_DEFAULT_GLOW);
+  const glowHeight = prominentGlow ? "70%" : "60%";
+  const glowGradient = prominentGlow ? `radial-gradient(ellipse 100% 80% at 50% 110%, ${glowColor} -10%, transparent 50%)` : `radial-gradient(ellipse 90% 75% at 50% 112%, ${glowColor} -15%, transparent 45%)`;
   return /* @__PURE__ */ jsxs(
     "div",
     {
@@ -29,8 +35,8 @@ function PerspectiveGrid({
               left: "50%",
               transform: "translateX(-50%)",
               width: "100%",
-              height: "60%",
-              background: `radial-gradient(ellipse 90% 75% at 50% 112%, ${glowColor} -15%, transparent 45%)`,
+              height: glowHeight,
+              background: glowGradient,
               pointerEvents: "none"
             }
           }
@@ -477,8 +483,9 @@ function CyberParticles({ variant: _variant, className }) {
   );
 }
 function CyberBackground({ variant }) {
+  const glowColor = variant === "volt" ? "color-mix(in srgb, var(--color-primary) 16%, transparent)" : void 0;
   return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(PerspectiveGrid, { lineColor: "var(--color-border)" }),
+    /* @__PURE__ */ jsx(PerspectiveGrid, { lineColor: "var(--color-border)", prominentGlow: true, glowColor }),
     /* @__PURE__ */ jsx(RadiantGlow, {}),
     /* @__PURE__ */ jsx(FloatingOrbs, {}),
     /* @__PURE__ */ jsx(CyberParticles, { variant }),

package/dist/{chunk-2Z7LYTIX.js → chunk-AQ5MQDSS.js}

@@ -1,12 +1,12 @@
-import { getTimeRangeDates, observabilityKeys } from './chunk-LXHZYSMQ.js';
 import { useSupabase } from './chunk-NJJ3NQ7B.js';
+import { getTimeRangeDates, observabilityKeys } from './chunk-LXHZYSMQ.js';
 import { GRAPH_CONSTANTS } from './chunk-F6RBK7NJ.js';
-import { useNotificationAdapter } from './chunk-UANJP5P7.js';
-import { HTTP_HEADERS } from './chunk-JNBHUCKW.js';
-import { STALE_TIME_MONITORING, REFETCH_INTERVAL_DASHBOARD, REFETCH_INTERVAL_RUNNING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, STALE_TIME_DEFAULT, STALE_TIME_ADMIN } from './chunk-MBZDE6UT.js';
+import { useNotificationAdapter } from './chunk-R7WLWGPO.js';
+import { HTTP_HEADERS } from './chunk-NVOCKXUQ.js';
+import { STALE_TIME_MONITORING, REFETCH_INTERVAL_DASHBOARD, REFETCH_INTERVAL_RUNNING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, STALE_TIME_DEFAULT, STALE_TIME_ADMIN } from './chunk-IOKL7BKE.js';
 import { useStableAccessToken } from './chunk-ALA56RGZ.js';
-import { useElevasisServices } from './chunk-QEPXAWE2.js';
 import { useOrganization } from './chunk-DD3CCMCZ.js';
+import { useElevasisServices } from './chunk-QEPXAWE2.js';
 import { useAuthContext } from './chunk-BRJ3QZ4E.js';
 import { useQuery, useQueryClient, useMutation, useQueries } from '@tanstack/react-query';
 import { z } from 'zod';
@@ -891,6 +891,31 @@ function useExecutionHealth({ timeRange }) {
     // 30s monitoring stale time
   });
 }
+function useNotificationCount(args) {
+  const { notificationCount, notificationConnected, notificationError } = args;
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  const query = useQuery({
+    queryKey: ["notifications", "unread-count", organizationId],
+    queryFn: async () => {
+      const response = await apiRequest("/notifications/unread-count");
+      return response.count;
+    },
+    enabled: isReady,
+    staleTime: Infinity
+    // SSE will keep it updated
+  });
+  return {
+    data: notificationCount !== null && notificationCount !== void 0 ? notificationCount : query.data,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    isSuccess: query.isSuccess,
+    status: query.status,
+    refetch: query.refetch,
+    sseConnected: notificationConnected,
+    sseError: notificationError
+  };
+}
 function useMarkAsRead() {
   const queryClient = useQueryClient();
   const { apiRequest } = useElevasisServices();
@@ -928,18 +953,6 @@ function useMarkAllAsRead() {
     }
   });
 }
-function useNotificationCount() {
-  const { apiRequest, isReady, organizationId } = useElevasisServices();
-  return useQuery({
-    queryKey: ["notifications", "unread-count", organizationId],
-    queryFn: async () => {
-      const response = await apiRequest("/notifications/unread-count");
-      return response.count;
-    },
-    enabled: isReady,
-    staleTime: 3e4
-  });
-}
 function useErrorNotification() {
   const adapter = useNotificationAdapter();
   return useCallback(