@elevasis/core 0.2.0 → 0.3.0

package/src/organization-model/defaults.ts

@@ -1,18 +1,23 @@
 import type { OrganizationModel } from './types'
+import {
+  DELIVERY_PROJECTS_VIEW_CAPABILITY_ID,
+  PROJECTS_FEATURE_ID,
+  PROJECTS_INDEX_SURFACE_ID
+} from './contracts'
 import { DEFAULT_ORGANIZATION_MODEL_BRANDING } from './domains/branding'
 import { DEFAULT_ORGANIZATION_MODEL_CRM } from './domains/crm'
 import { DEFAULT_ORGANIZATION_MODEL_DELIVERY } from './domains/delivery'
-import { DEFAULT_ORGANIZATION_MODEL_FEATURES } from './domains/features'
 import { DEFAULT_ORGANIZATION_MODEL_LEAD_GEN } from './domains/lead-gen'
 import { DEFAULT_ORGANIZATION_MODEL_NAVIGATION } from './domains/navigation'
 
 export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
   version: 1,
-  domains: [
+  features: [
     {
       id: 'crm',
       label: 'CRM',
       description: 'Relationship pipeline and deal management',
+      enabled: true,
       color: 'blue',
       entityIds: ['crm.deal'],
       surfaceIds: ['crm.pipeline'],
@@ -23,6 +28,7 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
       id: 'lead-gen',
       label: 'Lead Gen',
       description: 'Prospecting, qualification, and outreach preparation',
+      enabled: true,
       color: 'cyan',
       entityIds: ['leadgen.list', 'leadgen.company', 'leadgen.contact'],
       surfaceIds: ['lead-gen.lists'],
@@ -30,28 +36,56 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
       capabilityIds: ['leadgen.lists.manage']
     },
     {
-      id: 'delivery',
+      id: PROJECTS_FEATURE_ID,
       label: 'Projects',
       description: 'Projects, milestones, and client work execution',
+      enabled: true,
       color: 'orange',
       entityIds: ['delivery.project', 'delivery.milestone', 'delivery.task'],
-      surfaceIds: ['projects.index'],
+      surfaceIds: [PROJECTS_INDEX_SURFACE_ID],
       resourceIds: [],
-      capabilityIds: ['delivery.projects.view']
+      capabilityIds: [DELIVERY_PROJECTS_VIEW_CAPABILITY_ID]
     },
     {
       id: 'operations',
       label: 'Operations',
       description: 'Operational resources, topology, and orchestration visibility',
+      enabled: true,
       color: 'violet',
       entityIds: [],
       surfaceIds: ['operations.organization-graph', 'operations.command-view'],
       resourceIds: [],
       capabilityIds: ['operations.organization-graph', 'operations.command-view']
+    },
+    {
+      id: 'monitoring',
+      label: 'Monitoring',
+      enabled: true,
+      entityIds: [],
+      surfaceIds: [],
+      resourceIds: [],
+      capabilityIds: []
+    },
+    {
+      id: 'settings',
+      label: 'Settings',
+      enabled: true,
+      entityIds: [],
+      surfaceIds: [],
+      resourceIds: [],
+      capabilityIds: []
+    },
+    {
+      id: 'seo',
+      label: 'SEO',
+      enabled: false,
+      entityIds: [],
+      surfaceIds: [],
+      resourceIds: [],
+      capabilityIds: []
     }
   ],
   branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
-  features: DEFAULT_ORGANIZATION_MODEL_FEATURES,
   navigation: DEFAULT_ORGANIZATION_MODEL_NAVIGATION,
   crm: DEFAULT_ORGANIZATION_MODEL_CRM,
   leadGen: DEFAULT_ORGANIZATION_MODEL_LEAD_GEN,

package/src/organization-model/domains/features.ts

@@ -1,57 +1,22 @@
 import { z } from 'zod'
+import {
+  ColorTokenSchema,
+  DescriptionSchema,
+  IconNameSchema,
+  LabelSchema,
+  ModelIdSchema,
+  ReferenceIdsSchema
+} from './shared'
 
-export const FeatureKeySchema = z.enum([
-  'acquisition',
-  'delivery',
-  'operations',
-  'monitoring',
-  'settings',
-  'seo',
-  'calibration'
-])
-
-export const OrganizationModelFeaturesSchema = z.object({
-  enabled: z
-    .object({
-      acquisition: z.boolean().default(true),
-      delivery: z.boolean().default(true),
-      operations: z.boolean().default(true),
-      monitoring: z.boolean().default(true),
-      settings: z.boolean().default(true),
-      seo: z.boolean().default(false),
-      calibration: z.boolean().default(false)
-    })
-    .default({
-      acquisition: true,
-      delivery: true,
-      operations: true,
-      monitoring: true,
-      settings: true,
-      seo: false,
-      calibration: false
-    }),
-  labels: z
-    .object({
-      acquisition: z.string().trim().min(1).max(80).optional(),
-      delivery: z.string().trim().min(1).max(80).optional(),
-      operations: z.string().trim().min(1).max(80).optional(),
-      monitoring: z.string().trim().min(1).max(80).optional(),
-      settings: z.string().trim().min(1).max(80).optional(),
-      seo: z.string().trim().min(1).max(80).optional(),
-      calibration: z.string().trim().min(1).max(80).optional()
-    })
-    .default({})
+export const FeatureSchema = z.object({
+  id: ModelIdSchema,
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  enabled: z.boolean().default(true),
+  color: ColorTokenSchema.optional(),
+  icon: IconNameSchema.optional(),
+  entityIds: ReferenceIdsSchema,
+  surfaceIds: ReferenceIdsSchema,
+  resourceIds: ReferenceIdsSchema,
+  capabilityIds: ReferenceIdsSchema
 })
-
-export const DEFAULT_ORGANIZATION_MODEL_FEATURES: z.infer<typeof OrganizationModelFeaturesSchema> = {
-  enabled: {
-    acquisition: true,
-    delivery: true,
-    operations: true,
-    monitoring: true,
-    settings: true,
-    seo: false,
-    calibration: false
-  },
-  labels: {}
-}

package/src/organization-model/domains/navigation.ts

@@ -1,5 +1,9 @@
 import { z } from 'zod'
-import { FeatureKeySchema } from './features'
+import {
+  DELIVERY_PROJECTS_VIEW_CAPABILITY_ID,
+  PROJECTS_FEATURE_ID,
+  PROJECTS_INDEX_SURFACE_ID
+} from '../contracts'
 import { DescriptionSchema, IconNameSchema, LabelSchema, ModelIdSchema, PathSchema, ReferenceIdsSchema } from './shared'
 
 export const SurfaceTypeSchema = z.enum(['page', 'dashboard', 'graph', 'detail', 'list', 'settings'])
@@ -11,8 +15,8 @@ export const SurfaceDefinitionSchema = z.object({
   surfaceType: SurfaceTypeSchema,
   description: DescriptionSchema.optional(),
   icon: IconNameSchema.optional(),
-  featureKey: FeatureKeySchema.optional(),
-  domainIds: ReferenceIdsSchema,
+  featureId: ModelIdSchema.optional(),
+  featureIds: ReferenceIdsSchema,
   entityIds: ReferenceIdsSchema,
   resourceIds: ReferenceIdsSchema,
   capabilityIds: ReferenceIdsSchema,
@@ -40,8 +44,8 @@ export const DEFAULT_ORGANIZATION_MODEL_NAVIGATION: z.infer<typeof OrganizationM
       label: 'Pipeline',
       path: '/crm/pipeline',
       surfaceType: 'graph',
-      featureKey: 'acquisition',
-      domainIds: ['crm'],
+      featureId: 'crm',
+      featureIds: ['crm'],
       entityIds: ['crm.deal'],
       resourceIds: [],
       capabilityIds: ['crm.pipeline.manage']
@@ -51,30 +55,30 @@ export const DEFAULT_ORGANIZATION_MODEL_NAVIGATION: z.infer<typeof OrganizationM
       label: 'Lists',
       path: '/lead-gen/lists',
       surfaceType: 'list',
-      featureKey: 'acquisition',
-      domainIds: ['lead-gen'],
+      featureId: 'lead-gen',
+      featureIds: ['lead-gen'],
       entityIds: ['leadgen.list'],
       resourceIds: [],
       capabilityIds: ['leadgen.lists.manage']
     },
     {
-      id: 'projects.index',
+      id: PROJECTS_INDEX_SURFACE_ID,
       label: 'Projects',
       path: '/projects',
       surfaceType: 'list',
-      featureKey: 'delivery',
-      domainIds: ['delivery'],
+      featureId: PROJECTS_FEATURE_ID,
+      featureIds: [PROJECTS_FEATURE_ID],
       entityIds: ['delivery.project'],
       resourceIds: [],
-      capabilityIds: ['delivery.projects.view']
+      capabilityIds: [DELIVERY_PROJECTS_VIEW_CAPABILITY_ID]
     },
     {
       id: 'operations.organization-graph',
       label: 'Organization Graph',
       path: '/operations/organization-graph',
       surfaceType: 'graph',
-      featureKey: 'operations',
-      domainIds: ['operations'],
+      featureId: 'operations',
+      featureIds: ['operations'],
       entityIds: [],
       resourceIds: [],
       capabilityIds: ['operations.organization-graph']
@@ -84,15 +88,20 @@ export const DEFAULT_ORGANIZATION_MODEL_NAVIGATION: z.infer<typeof OrganizationM
       label: 'Command View',
       path: '/operations/command-view',
       surfaceType: 'graph',
-      featureKey: 'operations',
-      domainIds: ['operations'],
+      featureId: 'operations',
+      featureIds: ['operations'],
       entityIds: [],
       resourceIds: [],
       capabilityIds: ['operations.command-view']
     }
   ],
   groups: [
-    { id: 'primary-workspace', label: 'Workspace', placement: 'primary', surfaceIds: ['crm.pipeline', 'lead-gen.lists', 'projects.index'] },
+    {
+      id: 'primary-workspace',
+      label: 'Workspace',
+      placement: 'primary',
+      surfaceIds: ['crm.pipeline', 'lead-gen.lists', PROJECTS_INDEX_SURFACE_ID]
+    },
     {
       id: 'primary-operations',
       label: 'Operations',

package/src/organization-model/domains/shared.ts

@@ -22,21 +22,12 @@ export const DisplayMetadataSchema = z.object({
   icon: IconNameSchema.optional()
 })
 
-export const SemanticDomainSchema = DisplayMetadataSchema.extend({
-  id: ModelIdSchema,
-  entityIds: ReferenceIdsSchema,
-  surfaceIds: ReferenceIdsSchema,
-  resourceIds: ReferenceIdsSchema,
-  capabilityIds: ReferenceIdsSchema
-})
-
 export const ResourceMappingSchema = DisplayMetadataSchema.extend({
   id: ModelIdSchema,
   resourceId: z.string().trim().min(1).max(255),
   resourceType: z.enum(['workflow', 'agent', 'trigger', 'integration', 'external', 'human_checkpoint']),
-  domainIds: ReferenceIdsSchema,
+  featureIds: ReferenceIdsSchema,
   entityIds: ReferenceIdsSchema,
   surfaceIds: ReferenceIdsSchema,
   capabilityIds: ReferenceIdsSchema
 })
-

package/src/organization-model/foundation.ts

@@ -0,0 +1,96 @@
+import { PROJECTS_FEATURE_ID, PROJECTS_INDEX_SURFACE_ID } from './contracts'
+import { resolveOrganizationModel } from './resolve'
+import type { OrganizationModel, OrganizationModelSurface } from './types'
+
+export type FoundationSurfaceType = OrganizationModelSurface['surfaceType']
+
+export type FoundationSurfaceIcon = 'dashboard' | 'crm' | 'lead-gen' | 'projects' | 'operations' | 'settings'
+
+export interface FoundationNavigationSurface extends Omit<OrganizationModelSurface, 'icon'> {
+  icon?: FoundationSurfaceIcon
+}
+
+export interface FoundationOrganizationModel extends Omit<OrganizationModel, 'navigation'> {
+  navigation: {
+    defaultSurfaceId: string
+    homeLabel: string
+    quickAccessSurfaceIds: readonly string[]
+    surfaces: FoundationNavigationSurface[]
+  }
+}
+
+export interface FoundationBranding {
+  organizationName: string
+  productName: string
+  shortName: string
+}
+
+export function createFoundationOrganizationModel(branding: FoundationBranding): {
+  canonical: OrganizationModel
+  model: FoundationOrganizationModel
+  homeLabel: string
+  quickAccessSurfaceIds: readonly string[]
+  getOrganizationSurface: (surfaceId: string) => FoundationNavigationSurface | undefined
+} {
+  const canonical = resolveOrganizationModel({ branding })
+
+  function requireCoreSurface(surfaceId: string): OrganizationModelSurface {
+    const surface = canonical.navigation.surfaces.find((candidate) => candidate.id === surfaceId)
+
+    if (!surface) {
+      throw new Error(`Missing organization surface: ${surfaceId}`)
+    }
+
+    return surface
+  }
+
+  const operationsGraphSurface = requireCoreSurface('operations.organization-graph')
+  const projectsSurface = requireCoreSurface(PROJECTS_INDEX_SURFACE_ID)
+  const leadGenSurface = requireCoreSurface('lead-gen.lists')
+  const crmSurface = requireCoreSurface('crm.pipeline')
+
+  const navigationSurfaces: FoundationNavigationSurface[] = [
+    { ...operationsGraphSurface, id: 'operations', path: '/operations', icon: 'operations' },
+    { ...operationsGraphSurface, path: '/operations', icon: 'operations' },
+    { ...projectsSurface, id: PROJECTS_FEATURE_ID, icon: 'projects' },
+    { ...leadGenSurface, id: 'lead-gen', icon: 'lead-gen' },
+    { ...crmSurface, id: 'crm', icon: 'crm' },
+    {
+      id: 'settings',
+      label: 'Settings',
+      path: '/settings/account',
+      surfaceType: 'settings',
+      icon: 'settings',
+      featureId: 'settings',
+      featureIds: ['settings'],
+      entityIds: [],
+      resourceIds: [],
+      capabilityIds: []
+    }
+  ]
+
+  const homeLabel = 'Dashboard'
+  const quickAccessSurfaceIds = ['operations', PROJECTS_FEATURE_ID, 'lead-gen', 'crm'] as const
+
+  const model: FoundationOrganizationModel = {
+    ...canonical,
+    navigation: {
+      defaultSurfaceId: 'operations',
+      homeLabel,
+      quickAccessSurfaceIds: [...quickAccessSurfaceIds],
+      surfaces: navigationSurfaces
+    }
+  }
+
+  function getOrganizationSurface(surfaceId: string): FoundationNavigationSurface | undefined {
+    return model.navigation.surfaces.find((candidate) => candidate.id === surfaceId)
+  }
+
+  return {
+    canonical,
+    model,
+    homeLabel,
+    quickAccessSurfaceIds,
+    getOrganizationSurface
+  }
+}

package/src/organization-model/graph/build.ts

@@ -73,16 +73,6 @@ function ensureResourceNode(
   })
 }
 
-function titleCase(value: string): string {
-  return value
-    .replace(/[-_.]+/g, ' ')
-    .replace(/\s+/g, ' ')
-    .trim()
-    .split(' ')
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join(' ')
-}
-
 type CommandViewResource =
   | CommandViewData['workflows'][number]
   | CommandViewData['agents'][number]
@@ -126,38 +116,10 @@ export function buildOrganizationGraph(input: BuildOrganizationGraphInput): Orga
   }
   pushUniqueNode(nodes, nodeIds, organizationNode)
 
-  const featureEntries = Object.entries(organizationModel.features.enabled)
-    .map(([featureKey, enabled]) => {
-      const key = featureKey as keyof typeof organizationModel.features.enabled
-      return {
-        key: featureKey,
-        enabled,
-        label: organizationModel.features.labels[key] ?? titleCase(featureKey)
-      }
-    })
-    .sort((a, b) => a.key.localeCompare(b.key))
-
-  for (const feature of featureEntries) {
-    const id = nodeId('feature', feature.key)
-    pushUniqueNode(nodes, nodeIds, {
-      id,
-      kind: 'feature',
-      label: feature.label,
-      sourceId: feature.key,
-      enabled: feature.enabled,
-      featureKey: feature.key as OrganizationGraphNode['featureKey']
-    })
-    pushUniqueEdge(edges, edgeIds, {
-      id: edgeId('contains', organizationNode.id, id),
-      kind: 'contains',
-      sourceId: organizationNode.id,
-      targetId: id
-    })
-  }
-
-  const domainMap = new Map<string, (typeof organizationModel.domains)[number]>()
-  for (const domain of organizationModel.domains) {
-    domainMap.set(domain.id, domain)
+  // Build feature map for lookups
+  const featureMap = new Map<string, (typeof organizationModel.features)[number]>()
+  for (const feature of organizationModel.features) {
+    featureMap.set(feature.id, feature)
   }
 
   const surfaceMap = new Map<string, (typeof organizationModel.navigation.surfaces)[number]>()
@@ -167,7 +129,9 @@ export function buildOrganizationGraph(input: BuildOrganizationGraphInput): Orga
 
   const entityIds = new Set<string>()
   const capabilityIds = new Set<string>()
-  const resourceMappings = [...organizationModel.resourceMappings].sort((a, b) => a.resourceId.localeCompare(b.resourceId))
+  const resourceMappings = [...organizationModel.resourceMappings].sort((a, b) =>
+    a.resourceId.localeCompare(b.resourceId)
+  )
   for (const resourceMapping of resourceMappings) {
     for (const entityId of resourceMapping.entityIds) {
       entityIds.add(entityId)
@@ -177,14 +141,17 @@ export function buildOrganizationGraph(input: BuildOrganizationGraphInput): Orga
     }
   }
 
-  for (const domain of [...organizationModel.domains].sort((a, b) => a.id.localeCompare(b.id))) {
-    const id = nodeId('domain', domain.id)
+  // Unified feature loop: creates feature nodes with semantic data (replaces old feature + domain loops)
+  for (const feature of [...organizationModel.features].sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId('feature', feature.id)
     pushUniqueNode(nodes, nodeIds, {
       id,
-      kind: 'domain',
-      label: domain.label,
-      sourceId: domain.id,
-      description: domain.description
+      kind: 'feature',
+      label: feature.label,
+      sourceId: feature.id,
+      description: feature.description,
+      enabled: feature.enabled,
+      featureId: feature.id
     })
     pushUniqueEdge(edges, edgeIds, {
       id: edgeId('contains', organizationNode.id, id),
@@ -193,13 +160,13 @@ export function buildOrganizationGraph(input: BuildOrganizationGraphInput): Orga
       targetId: id
     })
 
-    for (const entityId of domain.entityIds) {
+    for (const entityId of feature.entityIds) {
       entityIds.add(entityId)
     }
-    for (const capabilityId of domain.capabilityIds) {
+    for (const capabilityId of feature.capabilityIds) {
       capabilityIds.add(capabilityId)
     }
-    for (const surfaceId of domain.surfaceIds) {
+    for (const surfaceId of feature.surfaceIds) {
       const surface = surfaceMap.get(surfaceId)
       if (surface) {
         pushUniqueEdge(edges, edgeIds, {
@@ -229,22 +196,22 @@ export function buildOrganizationGraph(input: BuildOrganizationGraphInput): Orga
       targetId: id
     })
 
-    if (surface.featureKey) {
+    if (surface.featureId) {
       pushUniqueEdge(edges, edgeIds, {
-        id: edgeId('exposes', nodeId('feature', surface.featureKey), id),
+        id: edgeId('exposes', nodeId('feature', surface.featureId), id),
         kind: 'exposes',
-        sourceId: nodeId('feature', surface.featureKey),
+        sourceId: nodeId('feature', surface.featureId),
         targetId: id
       })
     }
 
-    for (const domainId of surface.domainIds) {
-      if (domainMap.has(domainId)) {
+    for (const featureId of surface.featureIds) {
+      if (featureMap.has(featureId)) {
         pushUniqueEdge(edges, edgeIds, {
-          id: edgeId('references', id, nodeId('domain', domainId)),
+          id: edgeId('references', id, nodeId('feature', featureId)),
           kind: 'references',
           sourceId: id,
-          targetId: nodeId('domain', domainId)
+          targetId: nodeId('feature', featureId)
         })
       }
     }
@@ -317,13 +284,13 @@ export function buildOrganizationGraph(input: BuildOrganizationGraphInput): Orga
       targetId: id
     })
 
-    for (const domainId of resourceMapping.domainIds) {
-      if (domainMap.has(domainId)) {
+    for (const featureId of resourceMapping.featureIds) {
+      if (featureMap.has(featureId)) {
         pushUniqueEdge(edges, edgeIds, {
-          id: edgeId('maps_to', id, nodeId('domain', domainId)),
+          id: edgeId('maps_to', id, nodeId('feature', featureId)),
           kind: 'maps_to',
           sourceId: id,
-          targetId: nodeId('domain', domainId)
+          targetId: nodeId('feature', featureId)
         })
       }
     }
@@ -374,13 +341,13 @@ export function buildOrganizationGraph(input: BuildOrganizationGraphInput): Orga
         resourceType: normalizeCommandViewResourceType(resource.type)
       })
 
-      for (const domainId of resource.domains ?? []) {
-        if (domainMap.has(domainId)) {
+      for (const featureId of resource.domains ?? []) {
+        if (featureMap.has(featureId)) {
           pushUniqueEdge(edges, edgeIds, {
-            id: edgeId('references', resourceNode.id, nodeId('domain', domainId), 'domain'),
+            id: edgeId('references', resourceNode.id, nodeId('feature', featureId), 'feature'),
             kind: 'references',
             sourceId: resourceNode.id,
-            targetId: nodeId('domain', domainId)
+            targetId: nodeId('feature', featureId)
           })
         }
       }

package/src/organization-model/graph/schema.ts

@@ -1,13 +1,11 @@
 import { z } from 'zod'
-import { DescriptionSchema, LabelSchema } from '../domains/shared'
-import { FeatureKeySchema } from '../domains/features'
+import { DescriptionSchema, LabelSchema, ModelIdSchema } from '../domains/shared'
 import { SurfaceTypeSchema } from '../domains/navigation'
 import { OrganizationModelSchema } from '../schema'
 
 export const OrganizationGraphNodeKindSchema = z.enum([
   'organization',
   'feature',
-  'domain',
   'surface',
   'entity',
   'capability',
@@ -23,7 +21,7 @@ export const OrganizationGraphNodeSchema = z.object({
   sourceId: z.string().trim().min(1).max(255).optional(),
   description: DescriptionSchema.optional(),
   enabled: z.boolean().optional(),
-  featureKey: FeatureKeySchema.optional(),
+  featureId: ModelIdSchema.optional(),
   surfaceType: SurfaceTypeSchema.optional(),
   resourceType: z.enum(['workflow', 'agent', 'trigger', 'integration', 'external', 'human_checkpoint']).optional()
 })

package/src/organization-model/graph/types.ts

@@ -1,20 +1,8 @@
 import type { CommandViewData } from '../../platform/registry/command-view'
-import type {
-  OrganizationModel,
-  OrganizationModelFeatureKey,
-  OrganizationModelResourceMapping,
-  OrganizationModelSurface
-} from '../types'
+import type { OrganizationModel, OrganizationModelResourceMapping, OrganizationModelSurface } from '../types'
 import type { RelationshipType } from '../../platform/registry/command-view'
 
-export type OrganizationGraphNodeKind =
-  | 'organization'
-  | 'feature'
-  | 'domain'
-  | 'surface'
-  | 'entity'
-  | 'capability'
-  | 'resource'
+export type OrganizationGraphNodeKind = 'organization' | 'feature' | 'surface' | 'entity' | 'capability' | 'resource'
 
 export type OrganizationGraphEdgeKind = 'contains' | 'references' | 'exposes' | 'maps_to'
 
@@ -25,7 +13,7 @@ export interface OrganizationGraphNode {
   sourceId?: string
   description?: string
   enabled?: boolean
-  featureKey?: OrganizationModelFeatureKey
+  featureId?: string
   surfaceType?: OrganizationModelSurface['surfaceType']
   resourceType?: OrganizationModelResourceMapping['resourceType']
 }

package/src/organization-model/index.ts

@@ -1,7 +1,9 @@
 export * from './schema'
 export * from './types'
+export * from './contracts'
 export * from './defaults'
 export * from './resolve'
+export * from './foundation'
 export * from './graph'
 export * from './domains/branding'
 export * from './domains/crm'