@fluojs/runtime 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/bootstrap.js

@@ -6,7 +6,7 @@ import { createDispatcher, createHandlerMapping } from '@fluojs/http';
 import { DuplicateProviderError } from './errors.js';
 import { createBootstrapTimingDiagnostics } from './health/diagnostics.js';
 import { createConsoleApplicationLogger } from './logging/logger.js';
-import { compileModuleGraph, createRuntimeTokenSet, providerToken } from './module-graph.js';
+import { compileModuleGraph, providerToken } from './module-graph.js';
 import { createRuntimePlatformShell } from './platform-shell.js';
 import { APPLICATION_LOGGER, COMPILED_MODULES, HTTP_APPLICATION_ADAPTER, PLATFORM_SHELL, RUNTIME_CONTAINER } from './tokens.js';
 const DEFAULT_MICROSERVICE_TOKEN = Symbol.for('fluo.microservices.service');
@@ -67,6 +67,7 @@ async function runCleanupCallbacks(cleanups) {
 }
 async function closeRuntimeResources(options) {
   const errors = [];
+  resetReadinessState(options.modules);
   errors.push(...(await runCleanupCallbacks(options.runtimeCleanup)));
   try {
     await runShutdownHooks(options.lifecycleInstances, options.signal);
@@ -91,6 +92,7 @@ async function closeRuntimeResources(options) {
 }
 async function runBootstrapFailureCleanup(options) {
   const errors = [];
+  resetReadinessState(options.modules);
   errors.push(...(await runCleanupCallbacks(options.runtimeCleanup)));
   if (options.lifecycleInstances.length > 0) {
     try {
@@ -138,6 +140,15 @@ function hasReadinessStateMethods(value) {
 function isMicroserviceRuntime(value) {
   return hasMethod(value, 'listen');
 }
+function hasMicroserviceRuntimeClose(value) {
+  return typeof value.close === 'function';
+}
+async function closeMicroserviceRuntime(runtime, signal) {
+  if (!hasMicroserviceRuntimeClose(runtime)) {
+    return;
+  }
+  await runtime.close(signal);
+}
 function resetReadinessState(modules) {
   for (const compiledModule of modules) {
     if (hasReadinessStateMethods(compiledModule.type)) {
@@ -156,44 +167,115 @@ function createDuplicateProviderMessage(token, moduleName, existingModuleName) {
   const tokenLabel = typeof token === 'function' ? token.name || '<anonymous>' : String(token);
   return `Duplicate provider token "${tokenLabel}" registered in module "${moduleName}". Previously registered in module "${existingModuleName}".`;
 }
-function collectProvidersForContainer(modules, runtimeProviders, policy, logger) {
-  const selectedProviders = new Map();
+function createDuplicateRuntimeProviderMessage(token) {
+  const tokenLabel = typeof token === 'function' ? token.name || '<anonymous>' : String(token);
+  return `Duplicate runtime provider token "${tokenLabel}" registered.`;
+}
+function handleDuplicateProvider(token, moduleName, existingModuleName, policy, logger) {
+  const message = createDuplicateProviderMessage(token, moduleName, existingModuleName);
+  if (policy === 'throw') {
+    throw new DuplicateProviderError(message, {
+      module: moduleName,
+      token,
+      phase: 'provider registration',
+      hint: `Remove the duplicate registration from one of the modules, use container.override() for intentional replacements, or set duplicateProviderPolicy to 'warn' or 'ignore'.`
+    });
+  }
+  if (policy === 'warn') {
+    logger?.warn(message, 'BootstrapModule');
+  }
+}
+function handleDuplicateRuntimeProvider(token, policy, logger) {
+  const message = createDuplicateRuntimeProviderMessage(token);
+  if (policy === 'throw') {
+    throw new DuplicateProviderError(message, {
+      module: '<runtime>',
+      token,
+      phase: 'provider registration',
+      hint: `Remove the duplicate runtime provider registration, use container.override() after bootstrap for intentional replacements, or set duplicateProviderPolicy to 'warn' or 'ignore'.`
+    });
+  }
+  if (policy === 'warn') {
+    logger?.warn(message, 'BootstrapModule');
+  }
+}
+function selectEffectiveBootstrapProviders(modules, runtimeProviders, rootModule, policy, logger) {
+  const selectedRuntimeProviderIndexes = new Map();
+  const selectedModuleProviderIndexes = new Map();
+  const runtimeMultiTokens = new Set();
+  const runtimeSingleTokens = new Set();
+  const runtimeProviderEntries = [];
+  const moduleProviderEntries = [];
   for (const runtimeProvider of runtimeProviders ?? []) {
     const token = providerToken(runtimeProvider);
-    selectedProviders.set(token, {
+    const multi = isMultiProvider(runtimeProvider);
+    const existingRuntimeProviderIndex = selectedRuntimeProviderIndexes.get(token);
+    if (multi) {
+      runtimeMultiTokens.add(token);
+    } else {
+      runtimeSingleTokens.add(token);
+    }
+    if (!multi && existingRuntimeProviderIndex !== undefined) {
+      handleDuplicateRuntimeProvider(token, policy, logger);
+    }
+    runtimeProviderEntries.push({
       moduleName: '<runtime>',
       provider: runtimeProvider,
       source: 'runtime',
       token
     });
+    if (!multi) {
+      selectedRuntimeProviderIndexes.set(token, runtimeProviderEntries.length - 1);
+    }
   }
   for (const compiledModule of modules) {
     for (const provider of compiledModule.definition.providers ?? []) {
       const token = providerToken(provider);
-      const existing = selectedProviders.get(token);
-      if (existing && existing.source === 'module') {
-        const message = createDuplicateProviderMessage(token, compiledModule.type.name, existing.moduleName);
-        if (policy === 'throw') {
-          throw new DuplicateProviderError(message, {
-            module: compiledModule.type.name,
-            token,
-            phase: 'provider registration',
-            hint: `Remove the duplicate registration from one of the modules, use container.override() for intentional replacements, or set duplicateProviderPolicy to 'warn' or 'ignore'.`
-          });
-        }
-        if (policy === 'warn') {
-          logger?.warn(message, 'BootstrapModule');
-        }
+      const multi = isMultiProvider(provider);
+      const existingModuleProviderIndex = selectedModuleProviderIndexes.get(token);
+      const existing = existingModuleProviderIndex === undefined ? undefined : moduleProviderEntries[existingModuleProviderIndex];
+      if (!multi && existing && existing.source === 'module') {
+        handleDuplicateProvider(token, compiledModule.type.name, existing.moduleName, policy, logger);
       }
-      selectedProviders.set(token, {
+      const entry = {
         moduleName: compiledModule.type.name,
+        moduleType: compiledModule.type,
         provider,
         source: 'module',
         token
-      });
+      };
+      moduleProviderEntries.push(entry);
+      if (!multi) {
+        selectedModuleProviderIndexes.set(token, moduleProviderEntries.length - 1);
+      }
     }
   }
-  return [...selectedProviders.values()].map(entry => entry.provider);
+  const selectedModuleProviderIndexesSet = new Set(selectedModuleProviderIndexes.values());
+  const selectedRuntimeProviderIndexesSet = new Set(selectedRuntimeProviderIndexes.values());
+  const moduleProviders = [];
+  const rootModuleProviders = [];
+  const effectiveRuntimeProviders = runtimeProviderEntries.filter((entry, index) => isMultiProvider(entry.provider) || selectedRuntimeProviderIndexesSet.has(index)).map(entry => entry.provider);
+  moduleProviderEntries.forEach((entry, index) => {
+    const multi = isMultiProvider(entry.provider);
+    if (entry.source !== 'module' || !multi && !selectedModuleProviderIndexesSet.has(index)) {
+      return;
+    }
+    if (runtimeSingleTokens.has(entry.token) || runtimeMultiTokens.has(entry.token) && !multi) {
+      return;
+    }
+    moduleProviders.push(entry.provider);
+    if (entry.moduleType === rootModule) {
+      rootModuleProviders.push(entry.provider);
+    }
+  });
+  return {
+    moduleProviders,
+    rootModuleProviders,
+    runtimeProviders: effectiveRuntimeProviders
+  };
+}
+function isMultiProvider(provider) {
+  return typeof provider === 'object' && provider !== null && 'multi' in provider && provider.multi === true;
 }
 function registerControllers(container, modules) {
   for (const compiledModule of modules) {
@@ -251,18 +333,18 @@ export function bootstrapModule(rootModule, options = {}) {
   const container = new Container();
   const policy = options.duplicateProviderPolicy ?? 'warn';
   const runtimeProviders = options.providers ?? [];
-  const runtimeProviderTokens = createRuntimeTokenSet(runtimeProviders);
-  const moduleProviders = collectProvidersForContainer(modules, runtimeProviders, policy, options.logger).filter(provider => !runtimeProviderTokens.has(providerToken(provider)));
-  if (runtimeProviders.length > 0) {
-    container.register(...runtimeProviders);
+  const effectiveProviders = selectEffectiveBootstrapProviders(modules, runtimeProviders, rootModule, policy, options.logger);
+  if (effectiveProviders.runtimeProviders.length > 0) {
+    container.register(...effectiveProviders.runtimeProviders);
   }
-  if (moduleProviders.length > 0) {
-    container.register(...moduleProviders);
+  if (effectiveProviders.moduleProviders.length > 0) {
+    container.register(...effectiveProviders.moduleProviders);
   }
   registerControllers(container, modules);
   registerModuleMiddleware(container, modules);
   return {
     container,
+    effectiveProviders,
     modules,
     rootModule
   };
@@ -275,9 +357,10 @@ class FluoApplication {
   applicationState = 'bootstrapped';
   closed = false;
   closingPromise;
+  contextResolutionCache = new Map();
   lifecycleInstances;
   connectedMicroservices = [];
-  constructor(container, modules, rootModule, dispatcher, bootstrapTiming, adapter, hasHttpAdapter, platformShell, lifecycleInstances, logger, runtimeCleanup) {
+  constructor(container, modules, rootModule, dispatcher, bootstrapTiming, adapter, hasHttpAdapter, platformShell, lifecycleInstances, logger, runtimeCleanup, contextCacheableTokens) {
     this.container = container;
     this.modules = modules;
     this.rootModule = rootModule;
@@ -288,13 +371,18 @@ class FluoApplication {
     this.platformShell = platformShell;
     this.logger = logger;
     this.runtimeCleanup = runtimeCleanup;
+    this.contextCacheableTokens = contextCacheableTokens;
     this.lifecycleInstances = lifecycleInstances;
+    installContextCacheInvalidation(this.container, this.contextResolutionCache, this.contextCacheableTokens);
   }
   get state() {
     return this.applicationState;
   }
   async get(token) {
-    return this.container.resolve(token);
+    if (this.closed) {
+      return this.container.resolve(token);
+    }
+    return resolveContextToken(this.container, token, this.contextCacheableTokens, this.contextResolutionCache);
   }
 
   /**
@@ -312,12 +400,43 @@ class FluoApplication {
     if (!isMicroserviceRuntime(runtime)) {
       throw new InvariantError('Resolved microservice token does not implement listen().');
     }
-    const microservice = new FluoMicroserviceApplication(this, this.logger, runtime);
+    const microservice = new FluoMicroserviceApplication(this, this.logger, runtime, false);
     this.connectedMicroservices.push(microservice);
     return microservice;
   }
   async startAllMicroservices() {
-    await Promise.all(this.connectedMicroservices.map(async microservice => microservice.listen()));
+    const startedMicroservices = [];
+    for (const microservice of this.connectedMicroservices) {
+      try {
+        await microservice.listen();
+        startedMicroservices.push(microservice);
+      } catch (error) {
+        await this.rollbackStartedMicroservices(startedMicroservices);
+        throw error;
+      }
+    }
+  }
+  async rollbackStartedMicroservices(startedMicroservices) {
+    for (const microservice of [...startedMicroservices].reverse()) {
+      try {
+        await microservice.close('bootstrap-failed');
+      } catch (rollbackError) {
+        this.logger.error('Failed to roll back a started microservice after startup failure.', rollbackError, 'FluoApplication');
+      }
+    }
+  }
+  async closeConnectedMicroservices(signal) {
+    const errors = [];
+    for (const microservice of [...this.connectedMicroservices].reverse()) {
+      try {
+        await microservice.close(signal);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) {
+      throw createLifecycleCloseError(errors);
+    }
   }
 
   /**
@@ -359,13 +478,27 @@ class FluoApplication {
       return;
     }
     this.closingPromise = (async () => {
-      await closeRuntimeResources({
-        adapter: this.adapter,
-        container: this.container,
-        lifecycleInstances: this.lifecycleInstances,
-        runtimeCleanup: this.runtimeCleanup,
-        signal
-      });
+      const errors = [];
+      try {
+        await this.closeConnectedMicroservices(signal);
+      } catch (error) {
+        errors.push(error);
+      }
+      try {
+        await closeRuntimeResources({
+          adapter: this.adapter,
+          container: this.container,
+          lifecycleInstances: this.lifecycleInstances,
+          modules: this.modules,
+          runtimeCleanup: this.runtimeCleanup,
+          signal
+        });
+      } catch (error) {
+        errors.push(error);
+      }
+      if (errors.length > 0) {
+        throw createLifecycleCloseError(errors);
+      }
       this.closed = true;
       this.applicationState = 'closed';
     })();
@@ -380,16 +513,22 @@ class FluoApplication {
 class FluoApplicationContext {
   closed = false;
   closingPromise;
-  constructor(container, modules, rootModule, bootstrapTiming, lifecycleInstances, runtimeCleanup) {
+  contextResolutionCache = new Map();
+  constructor(container, modules, rootModule, bootstrapTiming, lifecycleInstances, runtimeCleanup, contextCacheableTokens) {
     this.container = container;
     this.modules = modules;
     this.rootModule = rootModule;
     this.bootstrapTiming = bootstrapTiming;
     this.lifecycleInstances = lifecycleInstances;
     this.runtimeCleanup = runtimeCleanup;
+    this.contextCacheableTokens = contextCacheableTokens;
+    installContextCacheInvalidation(this.container, this.contextResolutionCache, this.contextCacheableTokens);
   }
   async get(token) {
-    return this.container.resolve(token);
+    if (this.closed) {
+      return this.container.resolve(token);
+    }
+    return resolveContextToken(this.container, token, this.contextCacheableTokens, this.contextResolutionCache);
   }
   async close(signal) {
     if (this.closed) {
@@ -403,6 +542,7 @@ class FluoApplicationContext {
       await closeRuntimeResources({
         container: this.container,
         lifecycleInstances: this.lifecycleInstances,
+        modules: this.modules,
         runtimeCleanup: this.runtimeCleanup,
         signal
       });
@@ -420,10 +560,11 @@ class FluoMicroserviceApplication {
   closed = false;
   closingPromise;
   microserviceState = 'bootstrapped';
-  constructor(context, logger, runtime) {
+  constructor(context, logger, runtime, closeContextOnClose) {
     this.context = context;
     this.logger = logger;
     this.runtime = runtime;
+    this.closeContextOnClose = closeContextOnClose;
   }
   get container() {
     return this.context.container;
@@ -472,7 +613,24 @@ class FluoMicroserviceApplication {
       return;
     }
     this.closingPromise = (async () => {
-      await this.context.close(signal);
+      if (this.closeContextOnClose) {
+        const errors = [];
+        try {
+          await closeMicroserviceRuntime(this.runtime, signal);
+        } catch (error) {
+          errors.push(error);
+        }
+        try {
+          await this.context.close(signal);
+        } catch (error) {
+          errors.push(error);
+        }
+        if (errors.length > 0) {
+          throw createLifecycleCloseError(errors);
+        }
+      } else {
+        await closeMicroserviceRuntime(this.runtime, signal);
+      }
       this.closed = true;
       this.microserviceState = 'closed';
     })();
@@ -488,22 +646,113 @@ class FluoMicroserviceApplication {
 /**
  * lifecycle hook이 있는 singleton provider 인스턴스를 미리 해석해 둔다.
  */
-async function resolveLifecycleInstances(container, providers) {
-  const instances = [];
+async function resolveLifecycleInstances(container, providers, resolvedInstances = []) {
+  const lifecycleEntries = [];
   const seen = new Set();
   for (const provider of providers) {
-    const scope = providerScope(provider);
-    if (scope === 'request' || scope === 'transient') {
-      continue;
-    }
     const token = providerToken(provider);
     if (seen.has(token)) {
       continue;
     }
+    if (isHookBearingValueProvider(provider)) {
+      seen.add(token);
+      lifecycleEntries.push({
+        token,
+        useValue: provider.useValue
+      });
+      continue;
+    }
+    if (!isDirectSingletonContextProvider(provider)) {
+      continue;
+    }
     seen.add(token);
-    instances.push(await container.resolve(token));
+    lifecycleEntries.push({
+      token
+    });
+  }
+  const resolutionResults = await Promise.allSettled(lifecycleEntries.map(entry => entry.useValue ?? container.resolve(entry.token)));
+  let resolutionError;
+  let hasResolutionError = false;
+  for (const result of resolutionResults) {
+    if (result.status === 'fulfilled') {
+      resolvedInstances.push(result.value);
+      continue;
+    }
+    if (!hasResolutionError) {
+      resolutionError = result.reason;
+      hasResolutionError = true;
+    }
+  }
+  if (hasResolutionError) {
+    throw resolutionError;
   }
-  return instances;
+  return resolvedInstances;
+}
+function createContextCacheableTokenSet(effectiveProviders, runtimeTokens) {
+  const cacheableTokens = new Set(runtimeTokens);
+  for (const provider of effectiveProviders.runtimeProviders) {
+    if (!isDirectSingletonContextProvider(provider)) {
+      continue;
+    }
+    cacheableTokens.add(providerToken(provider));
+  }
+  for (const provider of effectiveProviders.rootModuleProviders) {
+    if (!isDirectSingletonContextProvider(provider)) {
+      continue;
+    }
+    cacheableTokens.add(providerToken(provider));
+  }
+  return cacheableTokens;
+}
+function isDirectSingletonContextProvider(provider) {
+  if (isMultiProvider(provider)) {
+    return false;
+  }
+  if (typeof provider === 'function') {
+    return providerScope(provider) === 'singleton';
+  }
+  if ('useExisting' in provider || 'useValue' in provider) {
+    return false;
+  }
+  return providerScope(provider) === 'singleton';
+}
+function isHookBearingValueProvider(provider) {
+  return typeof provider === 'object' && provider !== null && 'useValue' in provider && hasLifecycleHook(provider.useValue);
+}
+function hasLifecycleHook(value) {
+  return isOnModuleInit(value) || isOnApplicationBootstrap(value) || isOnModuleDestroy(value) || isOnApplicationShutdown(value);
+}
+function installContextCacheInvalidation(container, cache, cacheableTokens) {
+  const cacheInvalidatingContainer = container;
+  const override = cacheInvalidatingContainer.override.bind(container);
+  cacheInvalidatingContainer.override = (...providers) => {
+    const result = override(...providers);
+    cache.clear();
+    for (const provider of providers) {
+      const token = providerToken(provider);
+      if (isDirectSingletonContextProvider(provider)) {
+        cacheableTokens.add(token);
+      } else {
+        cacheableTokens.delete(token);
+      }
+    }
+    return result;
+  };
+}
+async function resolveContextToken(container, token, cacheableTokens, cache) {
+  if (!cacheableTokens.has(token)) {
+    return container.resolve(token);
+  }
+  const cached = cache.get(token);
+  if (cached) {
+    return cached;
+  }
+  const resolution = container.resolve(token).catch(error => {
+    cache.delete(token);
+    throw error;
+  });
+  cache.set(token, resolution);
+  return resolution;
 }
 
 /**
@@ -600,9 +849,9 @@ function registerRuntimeApplicationContextTokens(bootstrapped, platformShell) {
     useValue: platformShell
   });
 }
-async function resolveBootstrapLifecycleInstances(bootstrapped, runtimeProviders) {
-  const lifecycleProviders = [...runtimeProviders, ...bootstrapped.modules.flatMap(compiledModule => compiledModule.definition.providers ?? [])];
-  return resolveLifecycleInstances(bootstrapped.container, lifecycleProviders);
+async function resolveBootstrapLifecycleInstances(bootstrapped, resolvedInstances) {
+  const lifecycleProviders = [...bootstrapped.effectiveProviders.runtimeProviders, ...bootstrapped.effectiveProviders.moduleProviders];
+  return resolveLifecycleInstances(bootstrapped.container, lifecycleProviders, resolvedInstances);
 }
 async function runBootstrapLifecycle(modules, lifecycleInstances, logger, platformShell) {
   resetReadinessState(modules);
@@ -618,15 +867,21 @@ function createFilterErrorHandler(filters) {
   return async (error, request, response, requestId) => runExceptionFilters(filters, error, request, response, requestId);
 }
 function createRuntimeDispatcherOptions(bootstrapped, options, handlerMapping, errorHandler, logger) {
+  const converters = options.converters ?? [];
   const dispatcherOptions = {
     appMiddleware: options.middleware ?? [],
-    binder: new DefaultBinder(options.converters ?? []),
     handlerMapping,
     interceptors: options.interceptors ?? [],
     logger,
     observers: options.observers ?? [],
+    requestScope: {
+      converterDefinitions: converters
+    },
     rootContainer: bootstrapped.container
   };
+  if (converters.length > 0) {
+    dispatcherOptions.binder = new DefaultBinder(converters);
+  }
   if (errorHandler) {
     dispatcherOptions.onError = errorHandler;
   }
@@ -654,6 +909,7 @@ export async function bootstrapApplication(options) {
   const logger = options.logger ?? createConsoleApplicationLogger();
   let lifecycleInstances = [];
   let bootstrappedContainer;
+  let bootstrappedModules = [];
   const hasHttpAdapter = options.adapter !== undefined;
   const adapter = options.adapter ?? {
     async close() {},
@@ -671,6 +927,7 @@ export async function bootstrapApplication(options) {
     const bootstrapped = bootstrapModule(options.rootModule, {
       duplicateProviderPolicy: options.duplicateProviderPolicy,
       logger,
+      moduleGraphCache: options.moduleGraphCache,
       providers: runtimeProviders,
       validationTokens: [RUNTIME_CONTAINER, COMPILED_MODULES, HTTP_APPLICATION_ADAPTER]
     });
@@ -689,8 +946,9 @@ export async function bootstrapApplication(options) {
       });
     }
     bootstrappedContainer = bootstrapped.container;
+    bootstrappedModules = bootstrapped.modules;
     const resolveLifecycleStart = timingEnabled ? runtimePerformance.now() : 0;
-    lifecycleInstances = await resolveBootstrapLifecycleInstances(bootstrapped, runtimeProviders);
+    lifecycleInstances = await resolveBootstrapLifecycleInstances(bootstrapped, lifecycleInstances);
     lifecycleInstances.push({
       onModuleDestroy() {
         return platformShell.stop();
@@ -719,13 +977,14 @@ export async function bootstrapApplication(options) {
       });
     }
     const bootstrapTiming = timingEnabled ? createBootstrapTimingDiagnostics(timingPhases, runtimePerformance.now() - timingStart) : undefined;
-    return new FluoApplication(bootstrapped.container, bootstrapped.modules, options.rootModule, dispatcher, bootstrapTiming, adapter, hasHttpAdapter, platformShell, lifecycleInstances, logger, runtimeCleanup);
+    return new FluoApplication(bootstrapped.container, bootstrapped.modules, options.rootModule, dispatcher, bootstrapTiming, adapter, hasHttpAdapter, platformShell, lifecycleInstances, logger, runtimeCleanup, createContextCacheableTokenSet(bootstrapped.effectiveProviders, [RUNTIME_CONTAINER, COMPILED_MODULES, HTTP_APPLICATION_ADAPTER, PLATFORM_SHELL]));
   } catch (error) {
     logger.error('Failed to bootstrap the fluo application. Check the error below for what failed and how to fix it.', error, 'FluoFactory');
     await runBootstrapFailureCleanup({
       container: bootstrappedContainer,
       lifecycleInstances,
       logger,
+      modules: bootstrappedModules,
       runtimeCleanup,
       scope: 'application'
     });
@@ -764,6 +1023,7 @@ export class FluoFactory {
     const logger = options.logger ?? createConsoleApplicationLogger();
     let lifecycleInstances = [];
     let bootstrappedContainer;
+    let bootstrappedModules = [];
     const runtimeCleanup = [];
     const platformShell = createRuntimePlatformShell(options.platform?.components);
     const timingEnabled = options.diagnostics?.timing === true;
@@ -776,6 +1036,7 @@ export class FluoFactory {
       const bootstrapped = bootstrapModule(rootModule, {
         duplicateProviderPolicy: options.duplicateProviderPolicy,
         logger,
+        moduleGraphCache: options.moduleGraphCache,
         providers: runtimeProviders,
         validationTokens: [RUNTIME_CONTAINER, COMPILED_MODULES]
       });
@@ -794,8 +1055,9 @@ export class FluoFactory {
         });
       }
       bootstrappedContainer = bootstrapped.container;
+      bootstrappedModules = bootstrapped.modules;
       const resolveLifecycleStart = timingEnabled ? runtimePerformance.now() : 0;
-      lifecycleInstances = await resolveBootstrapLifecycleInstances(bootstrapped, runtimeProviders);
+      lifecycleInstances = await resolveBootstrapLifecycleInstances(bootstrapped, lifecycleInstances);
       lifecycleInstances.push({
         onModuleDestroy() {
           return platformShell.stop();
@@ -816,13 +1078,14 @@ export class FluoFactory {
         });
       }
       const bootstrapTiming = timingEnabled ? createBootstrapTimingDiagnostics(timingPhases, runtimePerformance.now() - timingStart) : undefined;
-      return new FluoApplicationContext(bootstrapped.container, bootstrapped.modules, rootModule, bootstrapTiming, lifecycleInstances, runtimeCleanup);
+      return new FluoApplicationContext(bootstrapped.container, bootstrapped.modules, rootModule, bootstrapTiming, lifecycleInstances, runtimeCleanup, createContextCacheableTokenSet(bootstrapped.effectiveProviders, [RUNTIME_CONTAINER, COMPILED_MODULES, PLATFORM_SHELL]));
     } catch (error) {
       logger.error('Failed to bootstrap application context. Check the error below for what failed and how to fix it.', error, 'FluoFactory');
       await runBootstrapFailureCleanup({
         container: bootstrappedContainer,
         lifecycleInstances,
         logger,
+        modules: bootstrappedModules,
         runtimeCleanup,
         scope: 'application context'
       });
@@ -848,9 +1111,13 @@ export class FluoFactory {
       if (!isMicroserviceRuntime(runtime)) {
         throw new InvariantError('Resolved microservice token does not implement listen().');
       }
-      return new FluoMicroserviceApplication(context, logger, runtime);
+      return new FluoMicroserviceApplication(context, logger, runtime, true);
     } catch (error) {
-      await context.close('bootstrap-failed');
+      try {
+        await context.close('bootstrap-failed');
+      } catch (cleanupError) {
+        logger.error('Failed to clean up after microservice bootstrap failure.', cleanupError, 'FluoFactory');
+      }
       logger.error('Failed to bootstrap microservice context. Check the error below for what failed and how to fix it.', error, 'FluoFactory');
       throw error;
     }