@elevasis/ui 2.66.0 → 2.68.0

package/dist/chunk-TUMSNGTX.js

@@ -0,0 +1,35 @@
+import { Table, Group, Text, Button } from '@mantine/core';
+import { IconChevronUp, IconChevronDown, IconSelector, IconTrash } from '@tabler/icons-react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/components/table/SortableHeader.tsx
+function SortableHeader({ column, children, sort, onToggle, style, w }) {
+  const isActive = sort.column === column;
+  return /* @__PURE__ */ jsx(Table.Th, { style: { ...style, cursor: "pointer", userSelect: "none" }, w, onClick: () => onToggle(column), children: /* @__PURE__ */ jsxs(Group, { gap: 4, wrap: "nowrap", children: [
+    children,
+    isActive ? sort.direction === "asc" ? /* @__PURE__ */ jsx(IconChevronUp, { size: 14 }) : /* @__PURE__ */ jsx(IconChevronDown, { size: 14 }) : /* @__PURE__ */ jsx(IconSelector, { size: 14, style: { opacity: 0.3 } })
+  ] }) });
+}
+function TableSelectionToolbar({ selectedCount, onDelete, isDeleting }) {
+  if (selectedCount === 0) return null;
+  return /* @__PURE__ */ jsxs(Group, { gap: "sm", children: [
+    /* @__PURE__ */ jsxs(Text, { size: "sm", fw: 600, c: "blue", children: [
+      selectedCount,
+      " selected"
+    ] }),
+    onDelete && /* @__PURE__ */ jsx(
+      Button,
+      {
+        size: "sm",
+        color: "red",
+        variant: "light",
+        leftSection: /* @__PURE__ */ jsx(IconTrash, { size: 16 }),
+        loading: isDeleting,
+        onClick: onDelete,
+        children: "Delete"
+      }
+    )
+  ] });
+}
+
+export { SortableHeader, TableSelectionToolbar };

package/dist/chunk-TYKAKJGW.js

@@ -0,0 +1,67 @@
+import { useCyberColors, useResourcesHealth, EmptyState, CyberLegendItem, CyberAreaChart } from './chunk-ZGCWTWBD.js';
+import { CardHeader } from './chunk-62GVNH5U.js';
+import { getTimeRangeDates, formatBucketTime } from './chunk-Y6I3IC45.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-UD657ICS.js

@@ -0,0 +1,589 @@
+import { OrganizationContext, useOrganization } from './chunk-DD3CCMCZ.js';
+import { useProfile, useUserProfile } from './chunk-RT4KRGZT.js';
+import { brandSupabaseOrgId, brandWorkOsOrgId } from './chunk-MQZE7SUI.js';
+import { useAuthContext } from './chunk-BRJ3QZ4E.js';
+import { useState, useRef, useEffect, useCallback, createElement } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { Badge, Group, Button, Loader, Menu, Text } from '@mantine/core';
+import { IconLock, IconChevronDown, IconBuilding, IconCheck } from '@tabler/icons-react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useAuth } from '@workos-inc/authkit-react';
+
+// src/organization/context/invalidate-org-scoped.ts
+function invalidateOrgScopedQueries(queryClient, orgIds) {
+  const ids = new Set(orgIds.filter((id) => !!id));
+  if (ids.size === 0) return;
+  void queryClient.invalidateQueries({
+    predicate: (query) => queryKeyReferencesOrg(query.queryKey, ids)
+  });
+}
+function queryKeyReferencesOrg(queryKey, orgIds) {
+  return queryKey.some((segment) => segmentReferencesOrg(segment, orgIds));
+}
+function segmentReferencesOrg(segment, orgIds) {
+  if (typeof segment === "string") return orgIds.has(segment);
+  if (Array.isArray(segment)) return segment.some((value) => typeof value === "string" && orgIds.has(value));
+  if (segment && typeof segment === "object") {
+    return Object.values(segment).some((value) => typeof value === "string" && orgIds.has(value));
+  }
+  return false;
+}
+
+// src/organization/context/OrganizationProvider.tsx
+function OrganizationProvider({ apiRequest, children }) {
+  const { user, organizationId: workosOrgId } = useAuthContext();
+  const { profile, error: profileError } = useProfile();
+  const queryClient = useQueryClient();
+  const [memberships, setMemberships] = useState([]);
+  const [currentWorkOSOrganizationId, setCurrentWorkOSOrganizationId] = useState(null);
+  const [currentSupabaseOrganizationId, setCurrentSupabaseOrganizationId] = useState(null);
+  const [currentMembership, setCurrentMembership] = useState(null);
+  const [isInitializing, setIsInitializing] = useState(true);
+  const [isOrgRefreshing, setIsOrgRefreshing] = useState(false);
+  const [error, setError] = useState(null);
+  const hasInitializedRef = useRef(false);
+  const [profileLoaded, setProfileLoaded] = useState(false);
+  useEffect(() => {
+    if (profile !== void 0 && profile !== null) {
+      setProfileLoaded(true);
+    }
+  }, [profile]);
+  useEffect(() => {
+    if (profileError && isInitializing && !hasInitializedRef.current) {
+      setIsInitializing(false);
+    }
+  }, [profileError, isInitializing]);
+  useEffect(() => {
+    if (!user) {
+      setMemberships([]);
+      setCurrentWorkOSOrganizationId(null);
+      setCurrentSupabaseOrganizationId(null);
+      setCurrentMembership(null);
+      setIsInitializing(false);
+      setIsOrgRefreshing(false);
+      setError(null);
+      hasInitializedRef.current = false;
+      setProfileLoaded(false);
+    }
+  }, [user]);
+  const applyMembership = useCallback((membership) => {
+    setCurrentMembership(membership);
+    setCurrentSupabaseOrganizationId(brandSupabaseOrgId(membership?.organization?.id));
+    setCurrentWorkOSOrganizationId(brandWorkOsOrgId(membership?.organization?.workos_org_id));
+  }, []);
+  const selectOrganization = useCallback(
+    (data) => {
+      let selected = null;
+      if (workosOrgId) {
+        selected = data.find((m) => m.organization?.workos_org_id === workosOrgId) ?? null;
+      }
+      if (!selected && profile?.last_visited_org) {
+        selected = data.find((m) => m.organizationId === profile.last_visited_org) ?? null;
+      }
+      if (!selected && data.length > 0) {
+        selected = data[0];
+      }
+      if (selected) {
+        applyMembership(selected);
+      }
+    },
+    [profile?.last_visited_org, workosOrgId, applyMembership]
+  );
+  const fetchAndInitialize = useCallback(async () => {
+    if (!user?.id || !profileLoaded) return;
+    setError(null);
+    if (memberships.length === 0) {
+      setIsInitializing(true);
+    } else {
+      setIsOrgRefreshing(true);
+    }
+    try {
+      const data = await apiRequest("/memberships/my-memberships");
+      if (!Array.isArray(data)) {
+        throw new Error("Invalid memberships response");
+      }
+      setMemberships(data);
+      if (data.length === 0) {
+        hasInitializedRef.current = true;
+        return;
+      }
+      if (!currentWorkOSOrganizationId) {
+        selectOrganization(data);
+      } else {
+        const stillPresent = data.find((m) => m.organization?.workos_org_id === currentWorkOSOrganizationId);
+        if (!stillPresent) {
+          applyMembership(data[0] ?? null);
+        } else {
+          applyMembership(stillPresent);
+        }
+      }
+      hasInitializedRef.current = true;
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load organizations");
+    } finally {
+      setIsInitializing(false);
+      setIsOrgRefreshing(false);
+    }
+  }, [
+    user?.id,
+    profileLoaded,
+    memberships.length,
+    apiRequest,
+    currentWorkOSOrganizationId,
+    selectOrganization,
+    applyMembership
+  ]);
+  useEffect(() => {
+    if (!user?.id || !profileLoaded || hasInitializedRef.current) return;
+    fetchAndInitialize();
+  }, [user?.id, profileLoaded, fetchAndInitialize]);
+  useEffect(() => {
+    if (!hasInitializedRef.current) return;
+    if (!workosOrgId) return;
+    if (workosOrgId === currentWorkOSOrganizationId) return;
+    const target = memberships.find((m) => m.organization?.workos_org_id === workosOrgId);
+    if (!target) return;
+    const previousWorkOSOrgId = currentWorkOSOrganizationId;
+    const previousSupabaseOrgId = currentSupabaseOrganizationId;
+    applyMembership(target);
+    invalidateOrgScopedQueries(queryClient, [
+      previousWorkOSOrgId,
+      previousSupabaseOrgId,
+      target.organization?.workos_org_id,
+      target.organizationId
+    ]);
+  }, [
+    workosOrgId,
+    currentWorkOSOrganizationId,
+    currentSupabaseOrganizationId,
+    memberships,
+    applyMembership,
+    queryClient
+  ]);
+  const switchOrganization = useCallback(
+    (workosOrgId2, options) => {
+      const target = memberships.find((m) => m.organization?.workos_org_id === workosOrgId2);
+      if (!target) return;
+      const previousWorkOSOrgId = currentWorkOSOrganizationId;
+      const previousSupabaseOrgId = currentSupabaseOrganizationId;
+      applyMembership(target);
+      invalidateOrgScopedQueries(queryClient, [
+        previousWorkOSOrgId,
+        previousSupabaseOrgId,
+        target.organization?.workos_org_id,
+        target.organizationId
+      ]);
+      if (options?.persist !== false) {
+        void apiRequest("/users/me", {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ lastVisitedOrg: target.organizationId })
+        }).catch((err) => {
+          console.warn("Failed to persist last_visited_org preference:", err);
+        });
+      }
+    },
+    [memberships, applyMembership, queryClient, apiRequest, currentWorkOSOrganizationId, currentSupabaseOrganizationId]
+  );
+  const retry = useCallback(async () => {
+    hasInitializedRef.current = false;
+    setError(null);
+    await fetchAndInitialize();
+  }, [fetchAndInitialize]);
+  const value = {
+    currentWorkOSOrganizationId,
+    currentSupabaseOrganizationId,
+    currentMembership,
+    memberships,
+    isInitializing,
+    isOrgRefreshing,
+    error,
+    switchOrganization,
+    retry
+  };
+  return createElement(OrganizationContext.Provider, { value }, children);
+}
+function RoleBadge({ name, isSystem }) {
+  return /* @__PURE__ */ jsx(Badge, { color: isSystem ? "gray" : "primary", variant: "light", children: /* @__PURE__ */ jsxs(Group, { gap: 4, wrap: "nowrap", children: [
+    isSystem && /* @__PURE__ */ jsx(IconLock, { size: 10 }),
+    name
+  ] }) });
+}
+function OrganizationSwitcher({
+  currentOrganization,
+  memberships,
+  isLoading,
+  onSwitch
+}) {
+  const [opened, setOpened] = useState(false);
+  const [switching, setSwitching] = useState(false);
+  const otherMemberships = memberships.filter((m) => m.organizationId !== currentOrganization?.id);
+  const handleSwitch = async (workosOrgId) => {
+    setSwitching(true);
+    try {
+      await onSwitch(workosOrgId);
+      setOpened(false);
+    } catch (error) {
+      console.error("Failed to switch organization:", error);
+    } finally {
+      setSwitching(false);
+    }
+  };
+  if (isLoading) {
+    return /* @__PURE__ */ jsx(Button, { variant: "light", size: "xs", disabled: true, children: /* @__PURE__ */ jsx(Loader, { size: 14 }) });
+  }
+  if (memberships.length === 0) {
+    return /* @__PURE__ */ jsx(Button, { variant: "light", size: "xs", disabled: true, children: "None" });
+  }
+  return /* @__PURE__ */ jsxs(Menu, { opened, onChange: setOpened, position: "bottom-start", withinPortal: true, children: [
+    /* @__PURE__ */ jsx(Menu.Target, { children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "light",
+        size: "xs",
+        leftSection: /* @__PURE__ */ jsx(IconBuilding, { size: 16 }),
+        rightSection: /* @__PURE__ */ jsx(IconChevronDown, { size: 14 }),
+        loading: switching,
+        children: /* @__PURE__ */ jsx(Text, { truncate: true, style: { maxWidth: 200 }, size: "xs", children: currentOrganization?.name || "Select Organization" })
+      }
+    ) }),
+    /* @__PURE__ */ jsxs(
+      Menu.Dropdown,
+      {
+        style: {
+          background: "var(--glass-background)",
+          backdropFilter: "var(--glass-blur)",
+          WebkitBackdropFilter: "var(--glass-blur)"
+        },
+        children: [
+          currentOrganization && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Menu.Label, { children: "Current Organization" }),
+            /* @__PURE__ */ jsx(Menu.Item, { disabled: true, rightSection: /* @__PURE__ */ jsx(IconCheck, { size: 14 }), leftSection: /* @__PURE__ */ jsx(IconBuilding, { size: 14 }), children: currentOrganization.name }),
+            otherMemberships.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx(Menu.Divider, {}),
+              /* @__PURE__ */ jsx(Menu.Label, { children: "Switch Organization" })
+            ] })
+          ] }),
+          otherMemberships.length > 0 && /* @__PURE__ */ jsx("div", { children: otherMemberships.map((membership, index) => /* @__PURE__ */ jsx(
+            Menu.Item,
+            {
+              leftSection: /* @__PURE__ */ jsx(IconBuilding, { size: 14 }),
+              rightSection: /* @__PURE__ */ jsx(
+                RoleBadge,
+                {
+                  slug: membership.role.slug,
+                  name: membership.role.slug.charAt(0).toUpperCase() + membership.role.slug.slice(1),
+                  isSystem: true
+                }
+              ),
+              onClick: () => {
+                const workosOrgId = membership.organization?.workos_org_id;
+                if (!workosOrgId) {
+                  console.error("Organization missing WorkOS ID:", membership.organization?.name);
+                  return;
+                }
+                handleSwitch(workosOrgId);
+              },
+              disabled: switching,
+              children: membership.organization?.name || "Unknown Organization"
+            },
+            `${membership.organizationId}-${index}`
+          )) }, "other-memberships"),
+          !currentOrganization && memberships.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Menu.Label, { children: "Select Organization" }),
+            memberships.map((membership) => /* @__PURE__ */ jsx(
+              Menu.Item,
+              {
+                leftSection: /* @__PURE__ */ jsx(IconBuilding, { size: 14 }),
+                rightSection: /* @__PURE__ */ jsx(
+                  RoleBadge,
+                  {
+                    slug: membership.role.slug,
+                    name: membership.role.slug.charAt(0).toUpperCase() + membership.role.slug.slice(1),
+                    isSystem: true
+                  }
+                ),
+                onClick: () => {
+                  const workosOrgId = membership.organization?.workos_org_id;
+                  if (!workosOrgId) {
+                    console.error("Organization missing WorkOS ID:", membership.organization?.name);
+                    return;
+                  }
+                  handleSwitch(workosOrgId);
+                },
+                disabled: switching,
+                children: membership.organization?.name || "Unknown Organization"
+              },
+              membership.organizationId
+            ))
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+function OrganizationSwitcherConnected({
+  isLoading: extraLoading = false,
+  onSwitched
+} = {}) {
+  const { switchToOrganization } = useAuth();
+  const { currentMembership, memberships, isInitializing, isOrgRefreshing, switchOrganization } = useOrganization();
+  return /* @__PURE__ */ jsx(
+    OrganizationSwitcher,
+    {
+      currentOrganization: currentMembership?.organization,
+      memberships,
+      isLoading: extraLoading || isInitializing || isOrgRefreshing,
+      onSwitch: async (workosOrgId) => {
+        await switchToOrganization({ organizationId: workosOrgId });
+        switchOrganization(workosOrgId);
+        onSwitched?.(workosOrgId);
+      }
+    }
+  );
+}
+
+// src/organization/store/organizationsSlice.ts
+var initialOrganizationsState = {
+  currentWorkOSOrganizationId: null,
+  currentSupabaseOrganizationId: null,
+  currentMembership: null,
+  isInitializing: true,
+  // Start as initializing
+  isOrgRefreshing: false,
+  error: null
+};
+var createOrganizationsSlice = (set, _get, _store) => ({
+  // Organizations state
+  organizations: initialOrganizationsState,
+  // Organization actions
+  setCurrentWorkOSOrganizationId: (workOSorgId) => {
+    set(
+      (state) => {
+        state.organizations.currentWorkOSOrganizationId = workOSorgId;
+      },
+      void 0,
+      "organizations/setCurrentWorkOSOrganizationId"
+    );
+  },
+  setCurrentMembership: (membership) => {
+    set(
+      (state) => {
+        state.organizations.currentMembership = membership;
+        state.organizations.currentSupabaseOrganizationId = brandSupabaseOrgId(membership?.organization?.id ?? null);
+      },
+      void 0,
+      "organizations/setCurrentMembership"
+    );
+  },
+  setOrganizationsInitializing: (initializing) => set(
+    (state) => {
+      state.organizations.isInitializing = initializing;
+    },
+    void 0,
+    "organizations/setInitializing"
+  ),
+  setOrganizationsLoading: (loading) => set(
+    (state) => {
+      state.organizations.isOrgRefreshing = loading;
+    },
+    void 0,
+    "organizations/setLoading"
+  ),
+  setOrganizationsError: (error) => set(
+    (state) => {
+      state.organizations.error = error;
+    },
+    void 0,
+    "organizations/setError"
+  )
+});
+
+// src/organization/hooks/useOrganizations.ts
+function createUseOrganizations(useStore) {
+  return () => {
+    const organizations = useStore((state) => state.organizations);
+    const setCurrentWorkOSOrganizationId = useStore((state) => state.setCurrentWorkOSOrganizationId);
+    const setCurrentMembership = useStore((state) => state.setCurrentMembership);
+    const setOrganizationsInitializing = useStore((state) => state.setOrganizationsInitializing);
+    const setOrganizationsLoading = useStore((state) => state.setOrganizationsLoading);
+    const setOrganizationsError = useStore((state) => state.setOrganizationsError);
+    return {
+      ...organizations,
+      setCurrentWorkOSOrganizationId,
+      setCurrentMembership,
+      setOrganizationsInitializing,
+      setOrganizationsLoading,
+      setOrganizationsError,
+      organizations
+      // Also return the full organizations object for easy access
+    };
+  };
+}
+function createUseOrgInitialization(useOrganizations, useApiClient) {
+  return function useOrgInitialization() {
+    const { user, organizationId: workosOrgId } = useAuthContext();
+    const { apiRequest } = useApiClient();
+    const { profile } = useUserProfile();
+    const {
+      currentWorkOSOrganizationId,
+      currentMembership,
+      setCurrentWorkOSOrganizationId,
+      setCurrentMembership,
+      setOrganizationsInitializing,
+      setOrganizationsLoading,
+      setOrganizationsError,
+      organizations
+    } = useOrganizations();
+    const [memberships, setMemberships] = useState([]);
+    const [profileLoaded, setProfileLoaded] = useState(false);
+    const hasInitializedRef = useRef(false);
+    const currentMembershipIdRef = useRef(null);
+    currentMembershipIdRef.current = currentMembership?.id ?? null;
+    useEffect(() => {
+      if (profile !== void 0 && profile !== null) {
+        setProfileLoaded(true);
+      }
+    }, [profile]);
+    const selectOrganization = useCallback(
+      async (data) => {
+        let selectedMembership = null;
+        if (workosOrgId) {
+          selectedMembership = data.find((m) => m.organization?.workos_org_id === workosOrgId) || null;
+        }
+        if (!selectedMembership && profile?.last_visited_org) {
+          const supabaseLastVisitedOrgId = profile.last_visited_org;
+          selectedMembership = data.find((m) => m.organizationId === supabaseLastVisitedOrgId) || null;
+        }
+        if (!selectedMembership && data.length > 0) {
+          selectedMembership = data[0];
+        }
+        if (selectedMembership) {
+          const workosSelectedOrgId = selectedMembership.organization?.workos_org_id;
+          if (workosSelectedOrgId) {
+            setCurrentWorkOSOrganizationId(brandWorkOsOrgId(workosSelectedOrgId));
+            setCurrentMembership(selectedMembership);
+          }
+        }
+      },
+      [profile?.last_visited_org, workosOrgId, setCurrentWorkOSOrganizationId, setCurrentMembership]
+    );
+    const validateCurrentOrganization = useCallback(
+      (data) => {
+        const workosCurrentOrgId = currentWorkOSOrganizationId;
+        const currentOrg = data.find((m) => m.organization?.workos_org_id === workosCurrentOrgId);
+        if (!currentOrg) {
+          setCurrentWorkOSOrganizationId(null);
+          setCurrentMembership(null);
+          if (data.length > 0) {
+            const fallbackOrg = data[0];
+            const workosFallbackOrgId = fallbackOrg.organization?.workos_org_id;
+            if (workosFallbackOrgId) {
+              setCurrentWorkOSOrganizationId(brandWorkOsOrgId(workosFallbackOrgId));
+              setCurrentMembership(fallbackOrg);
+            }
+          }
+        } else {
+          if (currentOrg.id !== currentMembershipIdRef.current) {
+            setCurrentMembership(currentOrg);
+          }
+        }
+      },
+      [currentWorkOSOrganizationId, setCurrentWorkOSOrganizationId, setCurrentMembership]
+    );
+    useEffect(() => {
+      const initializeOrganizations = async () => {
+        if (!user?.id || !profileLoaded) {
+          return;
+        }
+        if (hasInitializedRef.current) {
+          return;
+        }
+        if (memberships.length === 0) {
+          setOrganizationsInitializing(true);
+        } else {
+          setOrganizationsLoading(true);
+        }
+        setOrganizationsError(null);
+        try {
+          const data = await apiRequest("/memberships/my-memberships");
+          if (!Array.isArray(data)) {
+            throw new Error("Invalid memberships response");
+          }
+          setMemberships(data);
+          if (data.length === 0) {
+            setOrganizationsError(
+              "No organization memberships found. Please contact your administrator or try refreshing the page."
+            );
+            hasInitializedRef.current = true;
+            return;
+          }
+          if (!currentWorkOSOrganizationId && data.length > 0) {
+            await selectOrganization(data);
+          } else if (currentWorkOSOrganizationId) {
+            validateCurrentOrganization(data);
+          }
+          hasInitializedRef.current = true;
+        } catch (error) {
+          setOrganizationsError(error instanceof Error ? error.message : "Failed to load organizations");
+        } finally {
+          setOrganizationsInitializing(false);
+          setOrganizationsLoading(false);
+        }
+      };
+      initializeOrganizations();
+    }, [
+      user?.id,
+      profileLoaded,
+      profile?.last_visited_org,
+      currentWorkOSOrganizationId,
+      apiRequest,
+      setOrganizationsInitializing,
+      setOrganizationsLoading,
+      setOrganizationsError,
+      selectOrganization,
+      validateCurrentOrganization
+      // REMOVED: memberships.length - causes feedback loop (memberships change as RESULT of effect, not INPUT)
+    ]);
+    const retryInitialization = useCallback(async () => {
+      hasInitializedRef.current = false;
+      setOrganizationsError(null);
+      setOrganizationsInitializing(true);
+      try {
+        const data = await apiRequest("/memberships/my-memberships");
+        if (!Array.isArray(data)) {
+          throw new Error("Invalid memberships response");
+        }
+        setMemberships(data);
+        if (!currentWorkOSOrganizationId && data.length > 0) {
+          await selectOrganization(data);
+        } else if (currentWorkOSOrganizationId) {
+          validateCurrentOrganization(data);
+        }
+        hasInitializedRef.current = true;
+      } catch (error) {
+        setOrganizationsError(error instanceof Error ? error.message : "Failed to load organizations");
+      } finally {
+        setOrganizationsInitializing(false);
+      }
+    }, [
+      apiRequest,
+      currentWorkOSOrganizationId,
+      setOrganizationsError,
+      setOrganizationsInitializing,
+      selectOrganization,
+      validateCurrentOrganization
+    ]);
+    return {
+      memberships,
+      isInitializing: organizations.isInitializing,
+      isLoading: organizations.isOrgRefreshing,
+      isInitialized: hasInitializedRef.current && !organizations.isInitializing && !organizations.isOrgRefreshing,
+      error: organizations.error,
+      currentOrganization: currentMembership?.organization || null,
+      retry: retryInitialization
+    };
+  };
+}
+
+export { OrganizationProvider, OrganizationSwitcher, OrganizationSwitcherConnected, RoleBadge, createOrganizationsSlice, createUseOrgInitialization, createUseOrganizations, invalidateOrgScopedQueries };