docs: function bootstrap() {
        const { testing, tooling, items } = bootstrappingSchedule;
        assert.state( testing || items.length > 0, 'Nothing configured for bootstrap()' );
        assert.state( items.length <= 1, 'Multiple bootstrapping items are not supported yet' );
  
        const debugEventBus = tooling && provideSharedDebugEventBus();
        const services = createServices( configuration, artifacts, debugEventBus );
        const adapterInstances = bootstrapAdapters( services, [ plainAdapter, ...adapters ], artifacts );
  
        const instanceName = services.configuration.ensure( 'name' );
        const instance = makeTopic( instanceName );
  
        if( tooling ) {
           services.tooling.registerDebugInfo( tooling.debugInfo );
           exportInstance( instanceName, services );
           createExternalApi( services );
        }
  
        services.widgetLoader.registerWidgetAdapters( adapterInstances );
        announceInstance( services );
  
        const { log } = services;
        const promises = items.map( item => {
           const { type, name, id = generateId( name ) } = item;
  
           /**
            * An object of strings which together identify a bootstrapping item.
            *
            * @name ItemMeta
            * @constructor
            */
           const itemMeta = {
              /**
               * The (topic-formatted) name of the LaxarJS instance.
               * @name instance
               * @type {String}
               * @memberof ItemMeta
               */
              instance,
              /**
               * The (topic-formatted, ID-suffixed) name of the bootstrapping item.
               * @name item
               * @type {String}
               * @memberof ItemMeta
               */
              item: id,
              /**
               * The type of the bootstrapping item.
               * @name type
               * @type {String}
               * @memberof ItemMeta
               */
              type,
              /**
               * The artifact reference used for creating the bootstrapping item.
               * @name ${type}
               * @type {String}
               * @memberof ItemMeta
               */
              [ type ]: name
           };
  
           if( tooling ) {
              services.tooling.registerItem( itemMeta );
           }
  
           log.trace( `laxar.bootstrap: bootstrapping ${type} '${name}' (${id})` );
  
           if( type === 'flow' ) {
              const { anchorElement } = item;
  
              return whenDocumentReady( () => {
                 log.trace( `laxar.bootstrap: loading flow: ${name}` );
                 services.pageService.createControllerFor( anchorElement, itemMeta );
                 services.flowController
                    .loadFlow( name )
                    .then( () => {
                       log.trace( 'laxar.bootstrap: flow loaded' );
                    }, err => {
                       log.fatal( 'laxar.bootstrap: failed to load flow.' );
                       log.fatal( 'Error [0].\nStack: [1]', err, err && err.stack );
                    } );
              } );
           }
  
           if( type === 'page' ) {
              const { anchorElement, parameters } = item;
  
              return whenDocumentReady( () => {
                 const controller = services.pageService.createControllerFor( anchorElement, itemMeta );
                 const eventBus = services.globalEventBus;
                 const event = {
                    target: name,
                    place: null,
                    data: parameters
                 };
  
                 controller.setupPage( name )
                    .then( () => {
                       return eventBus.publish( `didNavigate.${event.target}`, event, { sender: 'bootstrap' } );
                    } )
                    .then( () => {
                       log.trace( 'laxar.bootstrap: page loaded' );
                    }, err => {
                       log.fatal( 'laxar.bootstrap: failed to load page.' );
                       log.fatal( 'Error [0].\nStack: [1]', err, err && err.stack );
                    } );
              } );
           }
  
           return assert.state( false );
        } );
  
        return Promise.all( promises ).then( () => {} );
     }