@fluojs/runtime 1.1.8 → 3.0.0

package/dist/adapters/request-response-factory.js

@@ -2,6 +2,55 @@
 
 /** Options for dispatching one raw platform request through a request/response factory. */
 
+/** An in-progress factory dispatch with its response shell available immediately. */
+
+/**
+ * Starts one raw platform request dispatch while exposing its mutable response shell.
+ *
+ * @param options - Factory, dispatcher, and raw platform request/response values for one dispatch.
+ * @returns The response shell and its independently settling dispatch lifecycle.
+ */
+export function startDispatchWithRequestResponseFactory({
+  dispatcher,
+  dispatcherNotReadyMessage,
+  factory,
+  rawRequest,
+  rawResponse
+}) {
+  const response = factory.createResponse(rawResponse, rawRequest);
+  const signal = factory.createRequestSignal(rawResponse);
+  let frameworkRequest;
+  const completion = (async () => {
+    try {
+      frameworkRequest = await factory.createRequest(rawRequest, signal);
+      const materializeRequest = factory.materializeRequest;
+      if (materializeRequest) {
+        await materializeRequest(frameworkRequest);
+      }
+      if (!dispatcher) {
+        throw new Error(dispatcherNotReadyMessage);
+      }
+      await dispatcher.dispatch(frameworkRequest, response);
+      if (!response.committed) {
+        await response.send(undefined);
+      }
+      return response;
+    } catch (error) {
+      if (signal.aborted || response.committed) {
+        return response;
+      }
+      await factory.writeErrorResponse(error, response, factory.resolveRequestId(rawRequest));
+      return response;
+    } finally {
+      await finalizeRouteOwnedMultipartBody(frameworkRequest);
+    }
+  })();
+  return {
+    completion,
+    response
+  };
+}
+
 /**
  * Dispatches one raw platform request through the shared request/response factory lifecycle.
  *
@@ -15,27 +64,31 @@ export async function dispatchWithRequestResponseFactory({
   rawRequest,
   rawResponse
 }) {
-  const frameworkResponse = factory.createResponse(rawResponse, rawRequest);
-  const signal = factory.createRequestSignal(rawResponse);
-  try {
-    const frameworkRequest = await factory.createRequest(rawRequest, signal);
-    const materializeRequest = factory.materializeRequest;
-    if (materializeRequest) {
-      await materializeRequest(frameworkRequest);
-    }
-    if (!dispatcher) {
-      throw new Error(dispatcherNotReadyMessage);
-    }
-    await dispatcher.dispatch(frameworkRequest, frameworkResponse);
-    if (!frameworkResponse.committed) {
-      await frameworkResponse.send(undefined);
-    }
-    return frameworkResponse;
-  } catch (error) {
-    if (signal.aborted || frameworkResponse.committed) {
-      return frameworkResponse;
-    }
-    await factory.writeErrorResponse(error, frameworkResponse, factory.resolveRequestId(rawRequest));
-    return frameworkResponse;
+  return await startDispatchWithRequestResponseFactory({
+    dispatcher,
+    dispatcherNotReadyMessage,
+    factory,
+    rawRequest,
+    rawResponse
+  }).completion;
+}
+
+/**
+ * Finalizes a route-owned multipart body iterator after dispatch completes.
+ *
+ * @param request Framework request whose multipart body may need finalization.
+ * @returns A promise that resolves after the iterator has been returned when applicable.
+ */
+export async function finalizeRouteOwnedMultipartBody(request) {
+  const body = request?.body;
+  if (!isAsyncIterable(body)) {
+    return;
+  }
+  const iterator = body[Symbol.asyncIterator]();
+  if (iterator.return) {
+    await iterator.return();
   }
+}
+function isAsyncIterable(value) {
+  return value !== null && (typeof value === 'object' || typeof value === 'function') && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === 'function';
 }

package/dist/bootstrap.d.ts

@@ -1,12 +1,6 @@
-import type { ApplicationContext, Application, MicroserviceApplication, BootstrapApplicationOptions, BootstrapModuleOptions, BootstrapResult, CreateApplicationOptions, CreateApplicationContextOptions, CreateMicroserviceOptions, ModuleDefinition, ModuleType } from './types.js';
-/**
- * Associates module metadata with a module type.
- *
- * @param moduleType Module class that should receive runtime module metadata.
- * @param definition Module definition contract (`imports`, `providers`, `controllers`, `exports`, etc.).
- * @returns The same `moduleType` reference for fluent helper composition.
- */
-export declare function defineModule<T extends ModuleType>(moduleType: T, definition: ModuleDefinition): T;
+import { defineModule } from './module-definition.js';
+import type { Application, ApplicationContext, BootstrapApplicationOptions, BootstrapModuleOptions, BootstrapResult, CreateApplicationContextOptions, CreateApplicationOptions, CreateMicroserviceOptions, MicroserviceApplication, ModuleType } from './types.js';
+export { defineModule };
 /**
  * Bootstraps the module graph and returns the root container baseline.
  *

package/dist/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EACV,kBAAkB,EAClB,WAAW,EAEX,uBAAuB,EAGvB,2BAA2B,EAC3B,sBAAsB,EACtB,eAAe,EAGf,wBAAwB,EACxB,+BAA+B,EAC/B,yBAAyB,EAEzB,gBAAgB,EAChB,UAAU,EAMX,MAAM,YAAY,CAAC;AA6dpB;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,gBAAgB,GAAG,CAAC,CAIjG;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,GAAE,sBAA2B,GAAG,eAAe,CA+B7G;AAo0BD;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,WAAW,CAAC,CAiJrG;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB;;;;;;;OAOG;WACU,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,GAAE,wBAA6B,GAAG,OAAO,CAAC,WAAW,CAAC;IAOzG;;;;;;;OAOG;WACU,wBAAwB,CACnC,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,kBAAkB,CAAC;IAwH9B;;;;;;;;OAQG;WACU,kBAAkB,CAC7B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,uBAAuB,CAAC;CA+BpC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,oBAAc,CAAC"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAmBtD,OAAO,KAAK,EACV,WAAW,EACX,kBAAkB,EAGlB,2BAA2B,EAE3B,sBAAsB,EACtB,eAAe,EAEf,+BAA+B,EAC/B,wBAAwB,EACxB,yBAAyB,EAEzB,uBAAuB,EAEvB,UAAU,EAMX,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,YAAY,EAAE,CAAC;AAuexB;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,GAAE,sBAA2B,GAAG,eAAe,CA+B7G;AA+8BD;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,WAAW,CAAC,CAiJrG;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB;;;;;;;OAOG;WACU,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,GAAE,wBAA6B,GAAG,OAAO,CAAC,WAAW,CAAC;IAOzG;;;;;;;OAOG;WACU,wBAAwB,CACnC,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,kBAAkB,CAAC;IAwH9B;;;;;;;;OAQG;WACU,kBAAkB,CAC7B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,uBAAuB,CAAC;CA+BpC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,oBAAc,CAAC"}

package/dist/bootstrap.js

@@ -1,15 +1,19 @@
-import { Container } from '@fluojs/di';
 import { InvariantError } from '@fluojs/core';
-import { createDispatcher, createHandlerMapping } from '@fluojs/http';
+import { Container } from '@fluojs/di';
+import { resolveMultiContribution } from '@fluojs/di/internal';
+import { createDispatcher, createHandlerMapping } from '@fluojs/http/portable';
+import { applyStudioDevtoolsApplicationOptions, applyStudioDevtoolsContextOptions, createStudioDevtoolsRuntimeFromConfig, publishStudioBootstrapSnapshot } from './devtools/studio-runtime.js';
 import { DuplicateProviderError } from './errors.js';
 import { createBootstrapTimingDiagnostics } from './health/diagnostics.js';
-import { applyStudioDevtoolsApplicationOptions, applyStudioDevtoolsContextOptions, createStudioDevtoolsRuntimeFromConfig, publishStudioBootstrapSnapshot } from './devtools/studio-runtime.js';
-import { defineRuntimeModuleMetadata, getRuntimeClassDiMetadata } from './internal/core-metadata.js';
+import { getRuntimeClassDiMetadata } from './internal/core-metadata.js';
 import { RuntimeDefaultBinder } from './internal/http-runtime.js';
 import { createDefaultApplicationLogger } from './logging/default-logger.js';
+import { defineModule } from './module-definition.js';
 import { compileModuleGraph, providerToken } from './module-graph.js';
 import { createRuntimePlatformShell } from './platform-shell.js';
-import { APPLICATION_LOGGER, BOOTSTRAP_READY_SIGNAL, COMPILED_MODULES, HTTP_APPLICATION_ADAPTER, PLATFORM_SHELL, RUNTIME_CLEANUP_REGISTRATION, RUNTIME_CONTAINER } from './tokens.js';
+import { createLifecycleCloseError, createRetryableShutdownState } from './retryable-shutdown.js';
+import { APPLICATION_LOGGER, BOOTSTRAP_PROVIDER_TOKENS, BOOTSTRAP_READY_SIGNAL, COMPILED_MODULES, HTTP_APPLICATION_ADAPTER, PLATFORM_SHELL, RUNTIME_CLEANUP_REGISTRATION, RUNTIME_CONTAINER } from './tokens.js';
+export { defineModule };
 const DEFAULT_MICROSERVICE_TOKEN = Symbol.for('fluo.microservices.service');
 const runtimePerformance = globalThis.performance;
 async function runExceptionFilters(filters, error, request, response, requestId) {
@@ -46,20 +50,11 @@ async function disposeContainer(container) {
   }
   await container.dispose();
 }
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-function createLifecycleCloseError(errors) {
-  if (errors.length === 1) {
-    return toError(errors[0]);
-  }
-  return new AggregateError(errors, 'Application close failed for one or more shutdown steps.');
-}
 async function runCleanupCallbacks(cleanups) {
   const errors = [];
   for (const cleanup of cleanups) {
     try {
-      cleanup();
+      await cleanup();
     } catch (error) {
       errors.push(error);
     }
@@ -95,24 +90,41 @@ function createBootstrapReadySignal() {
 }
 async function closeRuntimeResources(options) {
   const errors = [];
-  resetReadinessState(options.modules);
-  errors.push(...(await runCleanupCallbacks(options.runtimeCleanup)));
-  try {
-    await runShutdownHooks(options.lifecycleInstances, options.signal);
-  } catch (error) {
-    errors.push(error);
+  if (!options.shutdownState.isComplete('readiness')) {
+    resetReadinessState(options.modules);
+    options.shutdownState.complete('readiness');
+  }
+  if (!options.shutdownState.isComplete('runtime-cleanup')) {
+    const cleanupErrors = await runCleanupCallbacks(options.runtimeCleanup);
+    if (cleanupErrors.length === 0) {
+      options.shutdownState.complete('runtime-cleanup');
+    } else {
+      errors.push(...cleanupErrors);
+    }
   }
-  if (options.adapter) {
+  if (!options.shutdownState.isComplete('hooks')) {
     try {
-      await options.adapter.close(options.signal);
+      await runShutdownHooks(options.lifecycleInstances, options.signal);
+      options.shutdownState.complete('hooks');
     } catch (error) {
       errors.push(error);
     }
   }
-  try {
-    await disposeContainer(options.container);
-  } catch (error) {
-    errors.push(error);
+  if (!options.shutdownState.isComplete('adapter')) {
+    try {
+      await options.adapter?.close(options.signal);
+      options.shutdownState.complete('adapter');
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  if (!options.shutdownState.isComplete('container')) {
+    try {
+      await disposeContainer(options.container);
+      options.shutdownState.complete('container');
+    } catch (error) {
+      errors.push(error);
+    }
   }
   if (errors.length > 0) {
     throw createLifecycleCloseError(errors);
@@ -335,18 +347,6 @@ function registerModuleMiddleware(container, modules) {
   }
 }
 
-/**
- * Associates module metadata with a module type.
- *
- * @param moduleType Module class that should receive runtime module metadata.
- * @param definition Module definition contract (`imports`, `providers`, `controllers`, `exports`, etc.).
- * @returns The same `moduleType` reference for fluent helper composition.
- */
-export function defineModule(moduleType, definition) {
-  defineRuntimeModuleMetadata(moduleType, definition);
-  return moduleType;
-}
-
 /**
  * Bootstraps the module graph and returns the root container baseline.
  *
@@ -384,8 +384,11 @@ export function bootstrapModule(rootModule, options = {}) {
 class FluoApplication {
   applicationState = 'bootstrapped';
   closed = false;
+  closeStarted = false;
   closingPromise;
   listenPromise;
+  connectedMicroservicesClosed = false;
+  runtimeShutdownState = createRetryableShutdownState();
   contextResolutionCache = new Map();
   lifecycleInstances;
   connectedMicroservices = [];
@@ -411,7 +414,10 @@ class FluoApplication {
     if (this.closed) {
       return this.container.resolve(token);
     }
-    return resolveContextToken(this.container, token, this.contextCacheableTokens, this.contextResolutionCache);
+    this.assertProviderResolutionAllowed();
+    const resolved = await resolveContextToken(this.container, token, this.contextCacheableTokens, this.contextResolutionCache);
+    this.assertProviderResolutionAllowed();
+    return resolved;
   }
 
   /**
@@ -424,8 +430,10 @@ class FluoApplication {
     await this.platformShell.assertCriticalReadiness();
   }
   async connectMicroservice(options = {}) {
+    this.assertApplicationOperationAllowed('connect a microservice');
     const microserviceToken = options.microserviceToken ?? DEFAULT_MICROSERVICE_TOKEN;
     const runtime = await this.container.resolve(microserviceToken);
+    this.assertApplicationOperationAllowed('connect a microservice');
     if (!isMicroserviceRuntime(runtime)) {
       throw new InvariantError('Resolved microservice token does not implement listen().');
     }
@@ -434,9 +442,11 @@ class FluoApplication {
     return microservice;
   }
   async startAllMicroservices() {
+    this.assertApplicationOperationAllowed('start microservices');
     const startedMicroservices = [];
     for (const microservice of this.connectedMicroservices) {
       try {
+        this.assertApplicationOperationAllowed('start microservices');
         await microservice.listen();
         startedMicroservices.push(microservice);
       } catch (error) {
@@ -467,12 +477,22 @@ class FluoApplication {
       throw createLifecycleCloseError(errors);
     }
   }
+  assertApplicationOperationAllowed(operation) {
+    if (this.closeStarted) {
+      throw new InvariantError(`Application cannot ${operation} after shutdown has started.`);
+    }
+  }
+  assertProviderResolutionAllowed() {
+    if (this.closeStarted) {
+      throw new InvariantError('Application cannot resolve providers after shutdown has started.');
+    }
+  }
 
   /**
    * 준비 검사를 통과한 뒤 어댑터에 바인딩을 위임하고 상태를 `ready`로 전이한다.
    */
   async listen() {
-    if (this.closed || this.closingPromise || this.applicationState === 'closed') {
+    if (this.closeStarted) {
       throw new InvariantError('Application cannot listen after it has been closed.');
     }
     if (this.applicationState === 'ready') {
@@ -490,7 +510,7 @@ class FluoApplication {
     }
   }
   async startListening() {
-    if (this.closed || this.closingPromise || this.applicationState === 'closed') {
+    if (this.closeStarted) {
       throw new InvariantError('Application cannot listen after it has been closed.');
     }
     if (!this.hasHttpAdapter) {
@@ -503,13 +523,14 @@ class FluoApplication {
       this.logger.error('Failed to start the HTTP adapter.', error, 'FluoApplication');
       throw error;
     }
-    if (this.closed || this.closingPromise) {
+    if (this.closeStarted) {
       throw new InvariantError('Application startup was interrupted by shutdown.');
     }
     this.applicationState = 'ready';
     this.logger.log('fluo application successfully started.', 'FluoApplication');
   }
   dispatch = async (...args) => {
+    this.assertApplicationOperationAllowed('dispatch');
     await this.dispatcher.dispatch(...args);
   };
 
@@ -524,6 +545,7 @@ class FluoApplication {
       await this.closingPromise;
       return;
     }
+    this.closeStarted = true;
     this.closingPromise = (async () => {
       const errors = [];
       if (this.listenPromise) {
@@ -531,10 +553,13 @@ class FluoApplication {
           await this.listenPromise;
         } catch {}
       }
-      try {
-        await this.closeConnectedMicroservices(signal);
-      } catch (error) {
-        errors.push(error);
+      if (!this.connectedMicroservicesClosed) {
+        try {
+          await this.closeConnectedMicroservices(signal);
+          this.connectedMicroservicesClosed = true;
+        } catch (error) {
+          errors.push(error);
+        }
       }
       try {
         await closeRuntimeResources({
@@ -543,6 +568,7 @@ class FluoApplication {
           lifecycleInstances: this.lifecycleInstances,
           modules: this.modules,
           runtimeCleanup: this.runtimeCleanup,
+          shutdownState: this.runtimeShutdownState,
           signal
         });
       } catch (error) {
@@ -564,8 +590,10 @@ class FluoApplication {
 }
 class FluoApplicationContext {
   closed = false;
+  closeStarted = false;
   closingPromise;
   contextResolutionCache = new Map();
+  runtimeShutdownState = createRetryableShutdownState();
   constructor(container, modules, rootModule, bootstrapTiming, lifecycleInstances, runtimeCleanup, contextCacheableTokens) {
     this.container = container;
     this.modules = modules;
@@ -580,7 +608,15 @@ class FluoApplicationContext {
     if (this.closed) {
       return this.container.resolve(token);
     }
-    return resolveContextToken(this.container, token, this.contextCacheableTokens, this.contextResolutionCache);
+    this.assertProviderResolutionAllowed();
+    const resolved = await resolveContextToken(this.container, token, this.contextCacheableTokens, this.contextResolutionCache);
+    this.assertProviderResolutionAllowed();
+    return resolved;
+  }
+  assertProviderResolutionAllowed() {
+    if (this.closeStarted) {
+      throw new InvariantError('Application context cannot resolve providers after shutdown has started.');
+    }
   }
   async close(signal) {
     if (this.closed) {
@@ -590,12 +626,14 @@ class FluoApplicationContext {
       await this.closingPromise;
       return;
     }
+    this.closeStarted = true;
     this.closingPromise = (async () => {
       await closeRuntimeResources({
         container: this.container,
         lifecycleInstances: this.lifecycleInstances,
         modules: this.modules,
         runtimeCleanup: this.runtimeCleanup,
+        shutdownState: this.runtimeShutdownState,
         signal
       });
       this.closed = true;
@@ -610,6 +648,7 @@ class FluoApplicationContext {
 }
 class FluoMicroserviceApplication {
   closed = false;
+  closeStarted = false;
   closingPromise;
   listenPromise;
   microserviceState = 'bootstrapped';
@@ -635,7 +674,7 @@ class FluoMicroserviceApplication {
     return this.context.get(token);
   }
   async listen() {
-    if (this.closed || this.closingPromise || this.microserviceState === 'closed') {
+    if (this.closeStarted) {
       throw new InvariantError('Microservice cannot listen after it has been closed.');
     }
     if (this.microserviceState === 'ready') {
@@ -653,23 +692,25 @@ class FluoMicroserviceApplication {
     }
   }
   async startListening() {
-    if (this.closed || this.closingPromise || this.microserviceState === 'closed') {
+    if (this.closeStarted) {
       throw new InvariantError('Microservice cannot listen after it has been closed.');
     }
     await this.runtime.listen();
-    if (this.closed || this.closingPromise) {
+    if (this.closeStarted) {
       throw new InvariantError('Microservice startup was interrupted by shutdown.');
     }
     this.microserviceState = 'ready';
     this.logger.log('fluo microservice successfully started.', 'FluoFactory');
   }
   async send(pattern, payload, signal) {
+    this.assertTransportIngressOpen('send');
     if (!this.runtime.send) {
       throw new InvariantError('Resolved microservice runtime does not implement send().');
     }
     return await this.runtime.send(pattern, payload, signal);
   }
   async emit(pattern, payload) {
+    this.assertTransportIngressOpen('emit');
     if (!this.runtime.emit) {
       throw new InvariantError('Resolved microservice runtime does not implement emit().');
     }
@@ -683,7 +724,15 @@ class FluoMicroserviceApplication {
       await this.closingPromise;
       return;
     }
-    this.closingPromise = (async () => {
+    this.closeStarted = true;
+    let resolveClose = () => undefined;
+    let rejectClose = () => undefined;
+    this.closingPromise = new Promise((resolve, reject) => {
+      resolveClose = resolve;
+      rejectClose = reject;
+    });
+    void (async () => {
+      this.runtime.markShutdownStarted?.();
       if (this.listenPromise) {
         try {
           await this.listenPromise;
@@ -709,12 +758,12 @@ class FluoMicroserviceApplication {
       }
       this.closed = true;
       this.microserviceState = 'closed';
-    })();
-    try {
-      await this.closingPromise;
-    } catch (error) {
-      this.closingPromise = undefined;
-      throw error;
+    })().then(resolveClose, rejectClose);
+    await this.closingPromise;
+  }
+  assertTransportIngressOpen(operation) {
+    if (this.closeStarted) {
+      throw new InvariantError(`Microservice cannot ${operation} after shutdown has started.`);
     }
   }
 }
@@ -724,14 +773,33 @@ class FluoMicroserviceApplication {
  */
 async function resolveLifecycleInstances(container, providers, resolvedInstances = []) {
   const lifecycleEntries = [];
-  const seen = new Set();
+  const seenSingleTokens = new Set();
+  const multiContributionIndexes = new Map();
   for (const provider of providers) {
     const token = providerToken(provider);
-    if (seen.has(token)) {
+    if (isMultiProvider(provider)) {
+      const contributionIndex = multiContributionIndexes.get(token) ?? 0;
+      multiContributionIndexes.set(token, contributionIndex + 1);
+      if (isHookBearingValueProvider(provider)) {
+        lifecycleEntries.push({
+          token,
+          useValue: provider.useValue
+        });
+        continue;
+      }
+      if (isDirectSingletonContextProvider(provider, true)) {
+        lifecycleEntries.push({
+          contributionIndex,
+          token
+        });
+      }
+      continue;
+    }
+    if (seenSingleTokens.has(token)) {
       continue;
     }
     if (isHookBearingValueProvider(provider)) {
-      seen.add(token);
+      seenSingleTokens.add(token);
       lifecycleEntries.push({
         token,
         useValue: provider.useValue
@@ -741,17 +809,28 @@ async function resolveLifecycleInstances(container, providers, resolvedInstances
     if (!isDirectSingletonContextProvider(provider)) {
       continue;
     }
-    seen.add(token);
+    seenSingleTokens.add(token);
     lifecycleEntries.push({
       token
     });
   }
-  const resolutionResults = await Promise.allSettled(lifecycleEntries.map(entry => entry.useValue ?? container.resolve(entry.token)));
+  const resolutionResults = await Promise.allSettled(lifecycleEntries.map(entry => {
+    if (entry.useValue !== undefined) {
+      return entry.useValue;
+    }
+    if (entry.contributionIndex === undefined) {
+      return container.resolve(entry.token);
+    }
+    return resolveMultiContribution(container, entry.token, entry.contributionIndex);
+  }));
   let resolutionError;
   let hasResolutionError = false;
-  for (const result of resolutionResults) {
+  for (const [index, result] of resolutionResults.entries()) {
     if (result.status === 'fulfilled') {
-      resolvedInstances.push(result.value);
+      const entry = lifecycleEntries[index];
+      if (entry.contributionIndex === undefined || hasLifecycleHook(result.value)) {
+        resolvedInstances.push(result.value);
+      }
       continue;
     }
     if (!hasResolutionError) {
@@ -780,8 +859,8 @@ function createContextCacheableTokenSet(effectiveProviders, runtimeTokens) {
   }
   return cacheableTokens;
 }
-function isDirectSingletonContextProvider(provider) {
-  if (isMultiProvider(provider)) {
+function isDirectSingletonContextProvider(provider, includeMulti = false) {
+  if (isMultiProvider(provider) && !includeMulti) {
     return false;
   }
   if (typeof provider === 'function') {
@@ -851,21 +930,34 @@ async function runBootstrapHooks(instances) {
  * 종료 단계의 hook을 역순으로 실행해 이미 시작한 리소스를 정리한다.
  */
 async function runShutdownHooks(instances, signal) {
+  const errors = [];
   for (const instance of [...instances].reverse()) {
-    if (isOnModuleDestroy(instance)) {
-      await instance.onModuleDestroy();
+    try {
+      if (isOnModuleDestroy(instance)) {
+        await instance.onModuleDestroy();
+      }
+    } catch (error) {
+      errors.push(error);
     }
   }
   for (const instance of [...instances].reverse()) {
-    if (isOnApplicationShutdown(instance)) {
-      await instance.onApplicationShutdown(signal);
+    try {
+      if (isOnApplicationShutdown(instance)) {
+        await instance.onApplicationShutdown(signal);
+      }
+    } catch (error) {
+      errors.push(error);
     }
   }
+  if (errors.length > 0) {
+    throw createLifecycleCloseError(errors);
+  }
 }
 function createHandlerSources(modules) {
+  const globalModules = modules.filter(compiledModule => compiledModule.definition.global);
   return modules.flatMap(compiledModule => (compiledModule.definition.controllers ?? []).map(controllerToken => ({
     controllerToken,
-    moduleMiddleware: compiledModule.definition.middleware ?? [],
+    moduleMiddleware: [...globalModules.filter(globalModule => globalModule !== compiledModule).flatMap(globalModule => globalModule.definition.middleware ?? []), ...(compiledModule.definition.middleware ?? [])],
     moduleType: compiledModule.type
   })));
 }
@@ -896,7 +988,11 @@ function logRouteMappings(logger, descriptors) {
   }
 }
 function createRuntimeProviders(options, logger) {
+  const bootstrapProviderTokens = new Set((options.providers ?? []).map(providerToken));
   return [...(options.providers ?? []), {
+    provide: BOOTSTRAP_PROVIDER_TOKENS,
+    useValue: bootstrapProviderTokens
+  }, {
     provide: APPLICATION_LOGGER,
     useValue: logger
   }];
@@ -959,6 +1055,15 @@ function createRuntimeDispatcherOptions(bootstrapped, options, handlerMapping, e
   const converters = options.converters ?? [];
   const dispatcherOptions = {
     appMiddleware: options.middleware ?? [],
+    ...(options.contentNegotiation === undefined ? {} : {
+      contentNegotiation: options.contentNegotiation
+    }),
+    ...(options.conditionalRequest === undefined ? {} : {
+      conditionalRequest: options.conditionalRequest
+    }),
+    ...(options.errorRepresentation === undefined ? {} : {
+      errorRepresentation: options.errorRepresentation
+    }),
     handlerMapping,
     interceptors: options.interceptors ?? [],
     logger,
@@ -995,7 +1100,7 @@ function createRuntimeDispatcher(bootstrapped, options, logger) {
  * @throws {Error} Propagates module-graph, lifecycle, or runtime initialization failures.
  */
 export async function bootstrapApplication(options) {
-  const studioDevtools = createStudioDevtoolsRuntimeFromConfig();
+  const studioDevtools = options.studioDevtools ?? createStudioDevtoolsRuntimeFromConfig();
   const effectiveOptions = applyStudioDevtoolsApplicationOptions(options, studioDevtools);
   const logger = effectiveOptions.logger ?? createDefaultApplicationLogger();
   let lifecycleInstances = [];
@@ -1044,7 +1149,7 @@ export async function bootstrapApplication(options) {
     bootstrappedModules = bootstrapped.modules;
     const resolveLifecycleStart = timingEnabled ? runtimePerformance.now() : 0;
     lifecycleInstances = await resolveBootstrapLifecycleInstances(bootstrapped, lifecycleInstances);
-    lifecycleInstances.push({
+    lifecycleInstances.unshift({
       onModuleDestroy() {
         return platformShell.stop();
       }
@@ -1122,7 +1227,7 @@ export class FluoFactory {
    * @throws {Error} Propagates module-graph, lifecycle, and context bootstrap failures.
    */
   static async createApplicationContext(rootModule, options = {}) {
-    const studioDevtools = createStudioDevtoolsRuntimeFromConfig();
+    const studioDevtools = options.studioDevtools ?? createStudioDevtoolsRuntimeFromConfig();
     const effectiveOptions = applyStudioDevtoolsContextOptions(options, studioDevtools);
     const logger = createDefaultApplicationLogger();
     let lifecycleInstances = [];
@@ -1166,7 +1271,7 @@ export class FluoFactory {
       bootstrappedModules = bootstrapped.modules;
       const resolveLifecycleStart = timingEnabled ? runtimePerformance.now() : 0;
       lifecycleInstances = await resolveBootstrapLifecycleInstances(bootstrapped, lifecycleInstances);
-      lifecycleInstances.push({
+      lifecycleInstances.unshift({
         onModuleDestroy() {
           return platformShell.stop();
         }