@elevasis/ui 2.20.0 → 2.21.0

package/dist/{chunk-OUYH2SBS.js → chunk-LVUCBY7X.js}

@@ -1,6 +1,6 @@
-import { ApiClientProvider, useApiClient } from './chunk-R7OJCNL3.js';
+import { ApiClientProvider, useApiClient } from './chunk-T6INEVX6.js';
 import { OrganizationProvider } from './chunk-6IA2OMAE.js';
-import { getErrorInfo, getErrorTitle, formatErrorMessage } from './chunk-OD7GWIZS.js';
+import { getErrorInfo, getErrorTitle, formatErrorMessage } from './chunk-SGXXJE52.js';
 import { InitializationProvider } from './chunk-DK2HVHCY.js';
 import { useOrganization } from './chunk-DD3CCMCZ.js';
 import { ProfileProvider } from './chunk-QHSW4WHM.js';

package/dist/chunk-S7RL77QS.js

@@ -0,0 +1,48 @@
+import { useOptionalElevasisFeatures } from './chunk-VQESMHQV.js';
+import { useRouterContext } from './chunk-Q7DJKLEN.js';
+import { useMemo } from 'react';
+
+var useBreadcrumbs = (options = {}) => {
+  const { currentPath } = useRouterContext();
+  const featureContext = useOptionalElevasisFeatures();
+  const { labelsByPath = {} } = options;
+  return useMemo(() => {
+    const shellModel = featureContext?.shellModel;
+    const overriddenLabel = labelsByPath[currentPath];
+    if (overriddenLabel) {
+      return [{ label: overriddenLabel, isActive: true }];
+    }
+    if (shellModel) {
+      const matchedNode = shellModel.findByPath(currentPath);
+      if (matchedNode) {
+        return shellModel.ancestorsOf(matchedNode.id).map((node, index, items) => ({
+          label: labelsByPath[node.path ?? ""] ?? node.label,
+          path: index === items.length - 1 ? void 0 : node.path,
+          isActive: index === items.length - 1
+        }));
+      }
+    }
+    const segments = currentPath.split("/").filter(Boolean);
+    if (segments.length === 0) {
+      return [{ label: "Dashboard", isActive: true }];
+    }
+    const breadcrumbs = [{ label: "Dashboard", path: "/" }];
+    let currentSegmentPath = "";
+    for (let i = 0; i < segments.length; i++) {
+      currentSegmentPath += `/${segments[i]}`;
+      const isLast = i === segments.length - 1;
+      const label = labelsByPath[currentSegmentPath] ?? formatSegmentLabel(segments[i]);
+      breadcrumbs.push({
+        label,
+        path: isLast ? void 0 : currentSegmentPath,
+        isActive: isLast
+      });
+    }
+    return breadcrumbs;
+  }, [currentPath, featureContext, labelsByPath]);
+};
+function formatSegmentLabel(segment) {
+  return segment.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
+export { useBreadcrumbs };

package/dist/{chunk-OD7GWIZS.js → chunk-SGXXJE52.js}

@@ -191,126 +191,6 @@ z.object({
   endDate: z.string().datetime()
 });
 
-// ../core/src/platform/registry/domains.ts
-var DOMAINS = {
-  // Business domains
-  INBOUND_PIPELINE: "inbound-pipeline",
-  LEAD_GEN_PIPELINE: "lead-gen-pipeline",
-  SUPPORT: "support",
-  CLIENT_SUPPORT: "client-support",
-  DELIVERY: "delivery",
-  OPERATIONS: "operations",
-  FINANCE: "finance",
-  EXECUTIVE: "executive",
-  INSTANTLY: "instantly",
-  // Technical domains
-  TESTING: "testing",
-  INTERNAL: "internal",
-  INTEGRATION: "integration",
-  UTILITY: "utility",
-  DIAGNOSTIC: "diagnostic"
-};
-var INBOUND_PIPELINE_DOMAIN = {
-  id: DOMAINS.INBOUND_PIPELINE,
-  name: "Inbound Pipeline",
-  description: "End-to-end inbound client acquisition from first reply to onboarding",
-  color: "blue"
-};
-var LEAD_GEN_PIPELINE_DOMAIN = {
-  id: DOMAINS.LEAD_GEN_PIPELINE,
-  name: "Lead Gen Pipeline",
-  description: "Lead scraping, enrichment, qualification, and personalization",
-  color: "cyan"
-};
-var SUPPORT_DOMAIN = {
-  id: DOMAINS.SUPPORT,
-  name: "Customer Support",
-  description: "Ticket triage, knowledge base, escalations",
-  color: "green"
-};
-var CLIENT_SUPPORT_DOMAIN = {
-  id: DOMAINS.CLIENT_SUPPORT,
-  name: "Client Support",
-  description: "Client change requests, bug reports, and feature requests",
-  color: "teal"
-};
-var DELIVERY_DOMAIN = {
-  id: DOMAINS.DELIVERY,
-  name: "Client Delivery",
-  description: "Project execution and milestone tracking",
-  color: "orange"
-};
-var OPERATIONS_DOMAIN = {
-  id: DOMAINS.OPERATIONS,
-  name: "Operations",
-  description: "Internal business operations and administration",
-  color: "violet"
-};
-var FINANCE_DOMAIN = {
-  id: DOMAINS.FINANCE,
-  name: "Finance",
-  description: "Billing, invoicing, and financial operations",
-  color: "pink"
-};
-var EXECUTIVE_DOMAIN = {
-  id: DOMAINS.EXECUTIVE,
-  name: "Executive Operations",
-  description: "High-level business orchestration and decision-making",
-  color: "indigo"
-};
-var TESTING_DOMAIN = {
-  id: DOMAINS.TESTING,
-  name: "Testing",
-  description: "Test resources and development workflows",
-  color: "gray"
-};
-var INTERNAL_DOMAIN = {
-  id: DOMAINS.INTERNAL,
-  name: "Internal",
-  description: "Internal platform resources",
-  color: "dark"
-};
-var INTEGRATION_DOMAIN = {
-  id: DOMAINS.INTEGRATION,
-  name: "Integration",
-  description: "External service integrations",
-  color: "teal"
-};
-var INSTANTLY_DOMAIN = {
-  id: DOMAINS.INSTANTLY,
-  name: "Instantly Toolkit",
-  description: "Instantly campaign creation, analytics, and optimization",
-  color: "lime"
-};
-var UTILITY_DOMAIN = {
-  id: DOMAINS.UTILITY,
-  name: "Utility",
-  description: "Utility workflows for maintenance and diagnostics",
-  color: "grape"
-};
-var DIAGNOSTIC_DOMAIN = {
-  id: DOMAINS.DIAGNOSTIC,
-  name: "Diagnostic",
-  description: "Diagnostic workflows for testing integrations and services",
-  color: "yellow"
-};
-var DOMAIN_MAP = {
-  [DOMAINS.INBOUND_PIPELINE]: INBOUND_PIPELINE_DOMAIN,
-  [DOMAINS.LEAD_GEN_PIPELINE]: LEAD_GEN_PIPELINE_DOMAIN,
-  [DOMAINS.SUPPORT]: SUPPORT_DOMAIN,
-  [DOMAINS.CLIENT_SUPPORT]: CLIENT_SUPPORT_DOMAIN,
-  [DOMAINS.DELIVERY]: DELIVERY_DOMAIN,
-  [DOMAINS.OPERATIONS]: OPERATIONS_DOMAIN,
-  [DOMAINS.FINANCE]: FINANCE_DOMAIN,
-  [DOMAINS.EXECUTIVE]: EXECUTIVE_DOMAIN,
-  [DOMAINS.TESTING]: TESTING_DOMAIN,
-  [DOMAINS.INTERNAL]: INTERNAL_DOMAIN,
-  [DOMAINS.INSTANTLY]: INSTANTLY_DOMAIN,
-  [DOMAINS.INTEGRATION]: INTEGRATION_DOMAIN,
-  [DOMAINS.UTILITY]: UTILITY_DOMAIN,
-  [DOMAINS.DIAGNOSTIC]: DIAGNOSTIC_DOMAIN
-};
-
 // ../core/src/platform/registry/command-view.ts
 function getNodeId(node) {
   return node.resourceId;
@@ -504,4 +384,4 @@ function setupBrowserMocks() {
   setupResizeObserver();
 }
 
-export { APIClientError, API_URL, CredentialNameSchema, DEBOUNCE_FILTER, DEBOUNCE_SLIDER, DOMAIN_MAP, GC_TIME_LONG, GC_TIME_MEDIUM, GC_TIME_SHORT, LIMIT_ACTIVITY_FEED, NonEmptyStringSchema, OAUTH_FLOW_TIMEOUT, OAUTH_POPUP_CHECK_INTERVAL, OriginResourceTypeSchema, PAGE_SIZE_DEFAULT, REFETCH_INTERVAL_DASHBOARD, REFETCH_INTERVAL_REALTIME, REFETCH_INTERVAL_RUNNING, REFETCH_INTERVAL_RUNNING_FAST, ResourceTypeSchema, SSE_CLOSE_GRACE_PERIOD, SSE_TOKEN_REFRESH_DELAY, STALE_TIME_ADMIN, STALE_TIME_DEFAULT, STALE_TIME_MONITORING, UuidSchema, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, debounce, formatBucketTime, formatChartAxisDate, formatDate, formatDateTime, formatErrorMessage, formatRelativeTime, formatTimeAgo, getErrorInfo, getErrorTitle, getNodeId, getResourceColor, getResourceIcon, getTimeRangeDates, getTimeRangeLabel, isAPIClientError, restoreConsole, setupBrowserMocks, suppressKnownWarnings, validateEmail };
+export { APIClientError, API_URL, CredentialNameSchema, DEBOUNCE_FILTER, DEBOUNCE_SLIDER, GC_TIME_LONG, GC_TIME_MEDIUM, GC_TIME_SHORT, LIMIT_ACTIVITY_FEED, NonEmptyStringSchema, OAUTH_FLOW_TIMEOUT, OAUTH_POPUP_CHECK_INTERVAL, OriginResourceTypeSchema, PAGE_SIZE_DEFAULT, REFETCH_INTERVAL_DASHBOARD, REFETCH_INTERVAL_REALTIME, REFETCH_INTERVAL_RUNNING, REFETCH_INTERVAL_RUNNING_FAST, ResourceTypeSchema, SSE_CLOSE_GRACE_PERIOD, SSE_TOKEN_REFRESH_DELAY, STALE_TIME_ADMIN, STALE_TIME_DEFAULT, STALE_TIME_MONITORING, UuidSchema, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, debounce, formatBucketTime, formatChartAxisDate, formatDate, formatDateTime, formatErrorMessage, formatRelativeTime, formatTimeAgo, getErrorInfo, getErrorTitle, getNodeId, getResourceColor, getResourceIcon, getTimeRangeDates, getTimeRangeLabel, isAPIClientError, restoreConsole, setupBrowserMocks, suppressKnownWarnings, validateEmail };

package/dist/{chunk-R7OJCNL3.js → chunk-T6INEVX6.js}

@@ -1,4 +1,4 @@
-import { APIClientError } from './chunk-OD7GWIZS.js';
+import { APIClientError } from './chunk-SGXXJE52.js';
 import { OrganizationContext } from './chunk-DD3CCMCZ.js';
 import { createContext, useContext, useMemo, useCallback } from 'react';
 import { jsx } from 'react/jsx-runtime';

package/dist/{chunk-CTTY6FUT.js → chunk-TSSKOQBX.js}

@@ -1,6 +1,6 @@
 import { useErrorTrends } from './chunk-QSTH6T77.js';
-import { CardHeader, CenteredErrorState, TrendIndicator, EmptyState, StatCard } from './chunk-BHR7IV72.js';
-import { getTimeRangeLabel, getTimeRangeDates, formatBucketTime } from './chunk-OD7GWIZS.js';
+import { CardHeader, CenteredErrorState, TrendIndicator, EmptyState, StatCard } from './chunk-XUYBOO32.js';
+import { getTimeRangeLabel, getTimeRangeDates, formatBucketTime } from './chunk-SGXXJE52.js';
 import { useRef, useState, useLayoutEffect, useEffect, useMemo, useCallback } from 'react';
 import { jsx, jsxs } from 'react/jsx-runtime';
 import { useComputedColorScheme, Group, Text, Box, Stack, Center, Loader, Paper, Button, NumberFormatter, Badge, Space, Tooltip as Tooltip$1, SimpleGrid, Alert, SegmentedControl } from '@mantine/core';

package/dist/{chunk-Q4QJOSVS.js → chunk-ULZ2B3NC.js}

@@ -1,4 +1,4 @@
-import { ElevasisFeaturesProvider } from './chunk-LR5CRY5A.js';
+import { ElevasisFeaturesProvider } from './chunk-VQESMHQV.js';
 import { jsx } from 'react/jsx-runtime';
 
 function createTestFeaturesProvider({

package/dist/chunk-VQESMHQV.js

@@ -0,0 +1,336 @@
+import { useInitialization } from './chunk-DK2HVHCY.js';
+import { useOrganization } from './chunk-DD3CCMCZ.js';
+import { createContext, useMemo, useCallback, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+function createFeatureAccessHook({
+  useInitialization: useInitialization2,
+  useOrganization: useOrganization2
+}) {
+  return function useFeatureAccess2() {
+    const { profile, organizationReady } = useInitialization2();
+    const { currentMembership } = useOrganization2();
+    const { orgConfig, membershipConfig } = useMemo(() => {
+      const organizationConfig = currentMembership?.organization?.config;
+      const memberConfig = currentMembership?.config;
+      return { orgConfig: organizationConfig, membershipConfig: memberConfig };
+    }, [currentMembership]);
+    const userConfig = profile?.config;
+    const checkFeature = useCallback(
+      (featureKey) => {
+        if (profile?.is_platform_admin) {
+          return { allowed: true, restrictedBy: null };
+        }
+        const membershipValue = membershipConfig?.features?.[featureKey];
+        if (membershipValue === false) return { allowed: false, restrictedBy: "membership" };
+        return { allowed: true, restrictedBy: null };
+      },
+      [profile?.is_platform_admin, membershipConfig]
+    );
+    const hasFeature = useCallback((featureKey) => checkFeature(featureKey).allowed, [checkFeature]);
+    return {
+      orgConfig,
+      membershipConfig,
+      userConfig,
+      hasFeature,
+      checkFeature,
+      isReady: organizationReady
+    };
+  };
+}
+var createUseFeatureAccess = createFeatureAccessHook;
+
+// ../core/src/organization-model/helpers.ts
+function defaultPathFor(id) {
+  return `/${id.replaceAll(".", "/")}`;
+}
+function parentIdOf(id) {
+  const index = id.lastIndexOf(".");
+  return index === -1 ? void 0 : id.slice(0, index);
+}
+function findById(features, id) {
+  return features.find((feature) => feature.id === id);
+}
+function findByPath(features, path) {
+  return features.find((feature) => (feature.path ?? defaultPathFor(feature.id)) === path);
+}
+function childrenOf(features, id) {
+  const prefix = `${id}.`;
+  return features.filter((feature) => feature.id.startsWith(prefix) && !feature.id.slice(prefix.length).includes("."));
+}
+function topLevel(features) {
+  return features.filter((feature) => !feature.id.includes("."));
+}
+function ancestorsOf(features, id) {
+  const segments = id.split(".");
+  const ids = segments.map((_, index) => segments.slice(0, index + 1).join("."));
+  return ids.map((ancestorId) => findById(features, ancestorId)).filter((feature) => Boolean(feature));
+}
+function parentOf(features, id) {
+  const parentId = parentIdOf(id);
+  return parentId ? findById(features, parentId) : void 0;
+}
+function inheritedValue(features, id, getValue) {
+  return ancestorsOf(features, id).slice().reverse().map(getValue).find((value) => value !== void 0);
+}
+function uiPositionFor(features, id) {
+  return inheritedValue(features, id, (feature) => feature.uiPosition);
+}
+function requiresAdminFor(features, id) {
+  return inheritedValue(features, id, (feature) => feature.requiresAdmin) ?? false;
+}
+function devOnlyFor(features, id) {
+  return inheritedValue(features, id, (feature) => feature.devOnly) ?? false;
+}
+
+// src/provider/resolvers/RouteResolver.ts
+function normalizeRoutePath(path) {
+  const trimmedPath = path.trim();
+  if (!trimmedPath || trimmedPath === "/") {
+    return "/";
+  }
+  return trimmedPath.replace(/\/+$/, "") || "/";
+}
+function isRouteMatch(currentPath, route) {
+  const normalizedCurrentPath = normalizeRoutePath(currentPath);
+  const normalizedRoute = normalizeRoutePath(route);
+  return normalizedCurrentPath === normalizedRoute || normalizedCurrentPath.startsWith(`${normalizedRoute}/`);
+}
+
+// src/provider/resolvers/NavResolver.ts
+function uniqueIds(ids) {
+  return ids ? [...new Set(ids)] : [];
+}
+
+// src/provider/validateManifests.ts
+function validateManifests(manifests, organizationModel) {
+  if (!organizationModel) {
+    return;
+  }
+  const validFeatureIds = new Set(organizationModel.features.map((f) => f.id));
+  const errors = [];
+  for (const manifest of manifests) {
+    const key = manifest.key;
+    if (!validFeatureIds.has(manifest.featureId)) {
+      errors.push(
+        `Manifest "${key}": featureId "${manifest.featureId}" is not a known feature id. Valid values: ${[...validFeatureIds].sort().join(", ")}`
+      );
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(
+      `Feature manifest validation failed with ${errors.length} error(s):
+` + errors.map((e, i) => `  ${i + 1}. ${e}`).join("\n")
+    );
+  }
+}
+var useFeatureAccess = createFeatureAccessHook({
+  useInitialization,
+  useOrganization
+});
+var ElevasisFeaturesContext = createContext(null);
+function useElevasisFeatures() {
+  const context = useContext(ElevasisFeaturesContext);
+  if (!context) {
+    throw new Error(
+      "useElevasisFeatures must be used within an ElevasisFeaturesProvider. Wrap your app (or the relevant subtree) with <ElevasisFeaturesProvider>."
+    );
+  }
+  return context;
+}
+function useOptionalElevasisFeatures() {
+  return useContext(ElevasisFeaturesContext);
+}
+function defaultFeatures(organizationModel) {
+  return organizationModel?.features ?? [];
+}
+function featurePath(feature) {
+  return feature.path ?? defaultPathFor(feature.id);
+}
+function isOrganizationModelFeatureEnabled(organizationModel, featureId) {
+  const feature = organizationModel?.features.find((f) => f.id === featureId);
+  return feature?.enabled;
+}
+function resolveFeatureModules(features, isFeatureEnabled) {
+  return features.map((feature) => {
+    const featureId = feature.featureId;
+    return {
+      ...feature,
+      access: {
+        featureId,
+        enabled: isFeatureEnabled(featureId)
+      },
+      semantics: {
+        capabilityIds: uniqueIds(feature.capabilityIds ?? [])
+      }
+    };
+  });
+}
+function buildShellFeatures(organizationModel, modules) {
+  const iconByFeatureId = new Map(modules.map((module) => [module.featureId, module.icon]));
+  return defaultFeatures(organizationModel).map((feature) => ({
+    ...feature,
+    iconComponent: iconByFeatureId.get(feature.id)
+  }));
+}
+function createShellModel(features) {
+  return {
+    features,
+    findByPath: (path) => findByPath(features, normalizeRoutePath(path)),
+    findById: (id) => findById(features, id),
+    childrenOf: (id) => childrenOf(features, id),
+    ancestorsOf: (id) => ancestorsOf(features, id),
+    parentOf: (id) => parentOf(features, id),
+    topLevel: () => topLevel(features),
+    uiPositionFor: (id) => uiPositionFor(features, id),
+    requiresAdminFor: (id) => requiresAdminFor(features, id),
+    devOnlyFor: (id) => devOnlyFor(features, id)
+  };
+}
+function resolveOrganizationGraphFeature(features, shellModel) {
+  for (const feature of features) {
+    const graphBridge = feature.organizationGraph;
+    if (!graphBridge) continue;
+    const node = shellModel.findById(graphBridge.featureId);
+    return {
+      available: Boolean(node),
+      featureId: graphBridge.featureId,
+      featurePath: node ? featurePath(node) : void 0
+    };
+  }
+  return {
+    available: false
+  };
+}
+function findMatchingNode(shellModel, currentPath) {
+  const normalizedPath = normalizeRoutePath(currentPath);
+  const exact = shellModel.findByPath(normalizedPath);
+  if (exact) return exact;
+  return [...shellModel.features].filter((feature) => {
+    const path = normalizeRoutePath(featurePath(feature));
+    return path !== "/" && isRouteMatch(normalizedPath, path);
+  }).sort((a, b) => featurePath(b).length - featurePath(a).length)[0];
+}
+function ownsNode(module, node) {
+  if (!node) return false;
+  return node.id === module.featureId || node.id.startsWith(`${module.featureId}.`);
+}
+function resolveRoute(features, shellModel, currentPath, disabledSubsectionPaths) {
+  const node = findMatchingNode(shellModel, currentPath);
+  const normalizedPath = normalizeRoutePath(currentPath);
+  if (disabledSubsectionPaths.some((disabledPath) => isRouteMatch(normalizedPath, disabledPath))) {
+    return {
+      status: "hidden",
+      path: currentPath,
+      node
+    };
+  }
+  const feature = features.find((candidate) => ownsNode(candidate, node));
+  if (!feature) {
+    return {
+      status: "unmatched",
+      path: currentPath,
+      node
+    };
+  }
+  return {
+    status: "matched",
+    path: currentPath,
+    feature,
+    node
+  };
+}
+function ElevasisFeaturesProvider({
+  features,
+  organizationModel,
+  timeRange,
+  operationsApiUrl,
+  operationsSSEManager,
+  deliveryApiUrl,
+  deliverySSEManager,
+  disabledSubsectionPaths = [],
+  children
+}) {
+  useMemo(() => validateManifests(features, organizationModel), [features, organizationModel]);
+  const { hasFeature } = useFeatureAccess();
+  const hasResolvedFeature = useCallback(
+    (key) => {
+      if (!hasFeature(key)) {
+        return false;
+      }
+      const organizationModelFeatureEnabled = isOrganizationModelFeatureEnabled(organizationModel, key);
+      return organizationModelFeatureEnabled ?? true;
+    },
+    [hasFeature, organizationModel]
+  );
+  const shellFeatures = useMemo(() => buildShellFeatures(organizationModel, features), [organizationModel, features]);
+  const shellModel = useMemo(() => createShellModel(shellFeatures), [shellFeatures]);
+  const normalizedDisabledSubsectionPaths = useMemo(
+    () => [...new Set(disabledSubsectionPaths.map((path) => normalizeRoutePath(path)))],
+    [disabledSubsectionPaths]
+  );
+  const resolvedFeatures = useMemo(
+    () => resolveFeatureModules(features, hasResolvedFeature),
+    [features, hasResolvedFeature]
+  );
+  const enabledResolvedFeatures = useMemo(
+    () => resolvedFeatures.filter((feature) => feature.access.enabled),
+    [resolvedFeatures]
+  );
+  const organizationGraph = useMemo(
+    () => resolveOrganizationGraphFeature(enabledResolvedFeatures, shellModel),
+    [enabledResolvedFeatures, shellModel]
+  );
+  const getResolvedFeature = useCallback(
+    (key) => resolvedFeatures.find((feature) => feature.key === key),
+    [resolvedFeatures]
+  );
+  const isFeatureEnabled = useCallback((key) => hasResolvedFeature(key), [hasResolvedFeature]);
+  const resolveRouteByPath = useCallback(
+    (path) => resolveRoute(enabledResolvedFeatures, shellModel, path, normalizedDisabledSubsectionPaths),
+    [enabledResolvedFeatures, shellModel, normalizedDisabledSubsectionPaths]
+  );
+  const shellRuntime = useMemo(
+    () => ({
+      resolveRoute: resolveRouteByPath
+    }),
+    [resolveRouteByPath]
+  );
+  const value = useMemo(
+    () => ({
+      shellModel,
+      shellRuntime,
+      enabledResolvedFeatures,
+      resolvedFeatures,
+      organizationGraph,
+      organizationModel,
+      timeRange,
+      operationsApiUrl,
+      operationsSSEManager,
+      deliveryApiUrl,
+      deliverySSEManager,
+      disabledSubsectionPaths: normalizedDisabledSubsectionPaths,
+      isFeatureEnabled,
+      getResolvedFeature
+    }),
+    [
+      shellModel,
+      shellRuntime,
+      enabledResolvedFeatures,
+      resolvedFeatures,
+      organizationGraph,
+      organizationModel,
+      timeRange,
+      operationsApiUrl,
+      operationsSSEManager,
+      deliveryApiUrl,
+      deliverySSEManager,
+      normalizedDisabledSubsectionPaths,
+      isFeatureEnabled,
+      getResolvedFeature
+    ]
+  );
+  return /* @__PURE__ */ jsx(ElevasisFeaturesContext.Provider, { value, children });
+}
+
+export { ElevasisFeaturesProvider, createFeatureAccessHook, createUseFeatureAccess, useElevasisFeatures, useOptionalElevasisFeatures };

package/dist/{chunk-MZFJWCPH.js → chunk-XLZZOFGM.js}

@@ -2,10 +2,10 @@ import { AppShellLoader } from './chunk-M25JL54Z.js';
 import { FilterBar } from './chunk-PDHTXPSF.js';
 import { CustomModal } from './chunk-GBMNCNHX.js';
 import { useAvailablePresets } from './chunk-TIIPYB2Z.js';
-import { useDeleteCredential, useCreateCredential, useCredentials, MEMBERSHIP_STATUS_COLORS, transformMembershipToTableRow, useUserMemberships, useUpdateWebhookEndpoint, useResources, useDeleteWebhookEndpoint, useCreateWebhookEndpoint, useListWebhookEndpoints, useUpdateMemberConfig, useOrganizationMembers, useUpdateCredential, CredentialSchemas } from './chunk-FMFX4K6E.js';
-import { showErrorNotification } from './chunk-M7W7CGPL.js';
-import { ListSkeleton, EmptyState, PageTitleCaption, CardHeader, APIErrorAlert, StatCard } from './chunk-BHR7IV72.js';
-import { formatDateTime, OAUTH_POPUP_CHECK_INTERVAL, OAUTH_FLOW_TIMEOUT } from './chunk-OD7GWIZS.js';
+import { useDeleteCredential, useCreateCredential, useCredentials, MEMBERSHIP_STATUS_COLORS, transformMembershipToTableRow, useUserMemberships, useUpdateWebhookEndpoint, useResources, useDeleteWebhookEndpoint, useCreateWebhookEndpoint, useListWebhookEndpoints, useUpdateMemberConfig, useOrganizationMembers, useUpdateCredential, CredentialSchemas } from './chunk-7GG6OSD7.js';
+import { showErrorNotification } from './chunk-Z6FAH4XV.js';
+import { ListSkeleton, EmptyState, PageTitleCaption, CardHeader, APIErrorAlert, StatCard } from './chunk-XUYBOO32.js';
+import { formatDateTime, OAUTH_POPUP_CHECK_INTERVAL, OAUTH_FLOW_TIMEOUT } from './chunk-SGXXJE52.js';
 import { useInitialization } from './chunk-DK2HVHCY.js';
 import { useElevasisServices } from './chunk-IRW7JMQ4.js';
 import { Table, Group, Text, Tooltip, ActionIcon, Stack, Title, Button, Select, TextInput, Alert, PasswordInput, Anchor, Paper, Card, Switch, Badge, Center, Loader, Box, Code, CopyButton, ThemeIcon, SimpleGrid, UnstyledButton, Divider, Textarea } from '@mantine/core';
@@ -1980,21 +1980,7 @@ function OAuthIntegrationsCard({ apiUrl }) {
 var settingsManifest = {
   key: "settings",
   featureId: "settings",
-  navEntry: {
-    label: "Settings",
-    icon: IconSettings,
-    link: "/settings/account",
-    dataOnboardingTourId: "settings-gear",
-    links: [
-      { label: "Account", link: "/settings/account" },
-      { label: "Appearance", link: "/settings/appearance" },
-      { label: "Organization", link: "/settings/organization" },
-      { label: "Credentials", link: "/settings/credentials" },
-      { label: "API Keys", link: "/settings/api-keys" },
-      { label: "Webhooks", link: "/settings/webhooks" },
-      { label: "Deployments", link: "/settings/deployments" }
-    ]
-  }
+  icon: IconSettings
 };
 
 export { AccountSettings, AppearanceSettings, CreateCredentialModal, CreateWebhookEndpointModal, CredentialList, CredentialSettings, EditCredentialModal, EditWebhookEndpointModal, MemberConfigModal, MembershipFeaturePanel, MembershipStatusBadge, OAuthConnectModal, OAuthIntegrationsCard, OrgMembersList, OrganizationMembershipsList, OrganizationSettings, WebhookEndpointList, WebhookEndpointSettings, WebhookUrlDisplayModal, settingsManifest };

package/dist/{chunk-BHR7IV72.js → chunk-XUYBOO32.js}

@@ -1,6 +1,6 @@
 import { StyledMarkdown } from './chunk-3KMDHCAR.js';
 import { useRouterContext } from './chunk-Q7DJKLEN.js';
-import { getErrorInfo, getErrorTitle, getResourceIcon, formatTimeAgo } from './chunk-OD7GWIZS.js';
+import { getErrorInfo, getErrorTitle, getResourceIcon, formatTimeAgo } from './chunk-SGXXJE52.js';
 import { ResourceStatusColors } from './chunk-KRWALB24.js';
 import { useAuthContext } from './chunk-BRJ3QZ4E.js';
 import { Center, Stack, Title, Text, Button, Box, Loader, Badge, Group, Collapse, ScrollArea, Card, Select, Alert, Code, ThemeIcon, Paper, Grid, Timeline, Space } from '@mantine/core';

package/dist/{chunk-M7W7CGPL.js → chunk-Z6FAH4XV.js}

@@ -1,4 +1,4 @@
-import { getErrorInfo, formatErrorMessage, getErrorTitle } from './chunk-OD7GWIZS.js';
+import { getErrorInfo, formatErrorMessage, getErrorTitle } from './chunk-SGXXJE52.js';
 import { useElevasisServices } from './chunk-IRW7JMQ4.js';
 import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
 import { notifications } from '@mantine/notifications';