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

package/README.ko.md

@@ -27,7 +27,7 @@ npm install @fluojs/runtime
 - **fluo 애플리케이션 부트스트랩**: 모듈을 실행 중인 HTTP 서버나 마이크로서비스로 변환할 때.
 - **DI 및 라이프사이클 오케스트레이션**: 모듈 그래프 컴파일, 프로바이더 연결 및 애플리케이션 훅(`onModuleInit`, `onApplicationBootstrap`)을 관리할 때.
 - **독립형 컨텍스트 생성**: HTTP 서버는 필요 없지만 DI가 필요한 CLI 태스크, 마이그레이션 또는 워커를 실행할 때.
-- **진단 및 검사**: 기계 읽기 가능한 형태나 Mermaid 기반의 모듈 그래프 토폴로지를 내보낼 때.
+- **진단 및 검사**: CLI 내보내기와 Studio 소유 그래프 보기/렌더링을 위한 기계 읽기 가능한 플랫폼 snapshot을 생산할 때.
 
 ## 퀵 스타트
 
@@ -123,9 +123,18 @@ class UsersModule {}
 ## 동작 계약
 
 - 요청 바디 파싱은 Web 표준 요청과 Node 기반 요청 모두에서 바이트가 스트리밍되는 동안 `maxBodySize`를 강제합니다.
+- Node 기반 및 Web 표준 요청 wrapper는 바디 파싱 전에 저비용 요청 metadata를 snapshot으로 고정한 뒤 dispatch 경계에서 `body`/`rawBody`를 한 번 materialize하므로 userland는 계속 동기 parsed 값을 관찰합니다.
+- Node 기반 쿠키/쿼리 값과 Web 표준 헤더는 요청 wrapper가 생성되는 시점에 snapshot으로 고정된 뒤 요청별로 lazy하게 normalize되고 memoize됩니다. 이후 upstream 객체가 변경되어도 `FrameworkRequest` view는 바뀌지 않습니다.
+- `ApplicationContext.get()`과 `Application.get()`은 bootstrap 시점에 알려진 직접 root singleton class/factory provider 조회만 memoize하며, alias, request, transient, 종료 이후, multi-provider, `container.override()` 해석 의미는 그대로 유지합니다.
+- `multi: true` provider token은 context cache에 memoize되지 않습니다. 각 `get()` 호출은 DI로 위임되어 컨테이너가 새로운 contribution 배열을 조립하며, 각 contribution 자체는 해당 provider scope에 따라 재사용됩니다.
+- `duplicateProviderPolicy`가 `warn` 또는 `ignore`일 때 context cache 적격성과 lifecycle hook 실행은 bootstrap이 선택한 effective winning provider를 기준으로 결정됩니다. stale losing provider는 cache entry나 lifecycle hook을 만들지 않습니다.
+- 애플리케이션 또는 컨텍스트 bootstrap이 런타임 리소스나 lifecycle instance 생성 이후 실패하면 fluo는 readiness를 초기화하고, 등록된 runtime cleanup callback을 실행하며, 그 시점까지 해석된 instance의 shutdown hook을 `bootstrap-failed`로 호출하고, 컨테이너를 dispose하고, cleanup 실패를 로그로 남긴 뒤 원래 bootstrap error를 다시 던집니다.
+- Bootstrap은 독립적인 singleton lifecycle provider를 병렬로 해석한 뒤 lifecycle hook은 결정적인 provider 순서대로 실행합니다.
 - 멀티파트 파싱은 누적 바디 크기가 설정된 `multipart.maxTotalSize`를 넘으면 즉시 거부되며, 런타임 어댑터는 별도 재정의가 없으면 이 한도를 `maxBodySize`와 동일하게 맞춥니다.
 - 응답 스트림 백프레셔 헬퍼는 `drain`, `close`, `error` 중 어느 경우에도 `waitForDrain()`을 완료시켜 끊어진 연결에서 스트리밍 작성기가 멈추지 않도록 합니다.
+- 런타임 health 모듈은 bootstrap이 ready로 표시하기 전까지 `/ready`를 HTTP 503과 `starting`으로 보고하며, 애플리케이션/컨텍스트 종료가 시작되는 즉시, 종료 시도가 실패하더라도 다시 `starting`으로 내려갑니다.
 - 시그널 기반 종료 헬퍼는 bounded drain semantics를 유지하면서 timeout/실패 상황을 로그와 `process.exitCode`로 보고하지만, 최종 프로세스 종료 소유권은 주변 호스트 런타임에 남겨 둡니다.
+- 플랫폼 snapshot 생산은 런타임에 남아 있고, 그래프 보기와 Mermaid 렌더링은 CLI 및 자동화 호출자가 소비하는 Studio 소유 계약입니다.
 
 ## 공개 API 개요
 
@@ -134,6 +143,7 @@ class UsersModule {}
 - `Application`: `ApplicationContext`를 확장하며 `listen()`, `dispatch()`, `state`를 포함합니다.
 - `ApplicationContext`: `get<T>(token)`, `close()` 기능을 제공하며 `container`와 `modules`에 접근할 수 있습니다.
 - `LifecycleHooks`: `OnModuleInit`, `OnApplicationBootstrap`, `OnModuleDestroy`, `OnApplicationShutdown`를 묶는 편의 union 타입입니다.
+- `createHealthModule(options)`: bootstrap 및 shutdown 라이프사이클 전이에 맞춰 readiness marker를 관리하는 런타임 소유 `/health`, `/ready` 모듈 팩토리입니다.
 - `defineModule(cls, metadata)`: 프로그래밍 방식의 모듈 정의 헬퍼입니다.
 - `bootstrapApplication(options)`: 저수준 비동기 부트스트랩 함수입니다.
 
@@ -174,6 +184,7 @@ import {
 - [@fluojs/di](../di): 의존성 주입(DI) 컨테이너 구현체.
 - [@fluojs/http](../http): HTTP 라우팅, 컨트롤러 및 디스패처.
 - [@fluojs/platform-nodejs](../platform-nodejs): 공식 Node.js HTTP 어댑터.
+- [@fluojs/studio](../studio): 런타임이 생산한 snapshot을 위한 뷰어 및 렌더링 헬퍼.
 
 ## 예제 소스
 

package/README.md

@@ -27,7 +27,7 @@ Use this package when you need to:
 - **Bootstrap a fluo application**: Convert your modules into a running HTTP server or microservice.
 - **Orchestrate DI and Lifecycle**: Manage module-graph compilation, provider wiring, and application hooks (`onModuleInit`, `onApplicationBootstrap`).
 - **Create Standalone Contexts**: Run CLI tasks, migrations, or workers that need DI but not an HTTP server.
-- **Diagnostic Inspection**: Export machine-readable or Mermaid-based module graph topology.
+- **Diagnostic Inspection**: Produce machine-readable platform snapshots for CLI export and Studio-owned graph viewing/rendering.
 
 ## Quick Start
 
@@ -123,9 +123,18 @@ class UsersModule {}
 ## Behavioral Contracts
 
 - Request body parsing enforces `maxBodySize` while bytes are still streaming for both Web-standard and Node-backed requests.
+- Node-backed and Web-standard request wrappers snapshot cheap request metadata before body parsing, then materialize `body`/`rawBody` once at the dispatch boundary so userland continues to observe synchronous parsed values.
+- Node-backed cookies/query values and Web-standard headers are snapshotted when the request wrapper is created, then lazily normalized and memoized per request; later upstream object mutations do not change the `FrameworkRequest` view.
+- `ApplicationContext.get()` and `Application.get()` memoize only direct root singleton class/factory provider lookups known at bootstrap, while preserving alias, request, transient, post-close, multi-provider, and `container.override()` resolution semantics.
+- `multi: true` provider tokens are not context-cache memoized: each `get()` call delegates to DI so the container can assemble a fresh contribution array while still reusing each contribution according to its own provider scope.
+- When `duplicateProviderPolicy` is `warn` or `ignore`, context-cache eligibility and lifecycle hook execution are based on the effective winning provider selected by bootstrap; stale losing providers do not seed cache entries or lifecycle hooks.
+- If application or context bootstrap fails after runtime resources or lifecycle instances have been created, fluo resets readiness, runs registered runtime cleanup callbacks, invokes shutdown hooks for instances resolved so far with `bootstrap-failed`, disposes the container, logs cleanup failures, and rethrows the original bootstrap error.
+- Bootstrap resolves independent singleton lifecycle providers concurrently, then runs lifecycle hooks in deterministic provider order.
 - Multipart parsing rejects payloads when the cumulative body size exceeds the configured `multipart.maxTotalSize`; runtime adapters default that limit to `maxBodySize` unless you override it.
 - Response stream backpressure helpers settle `waitForDrain()` on `drain`, `close`, or `error` so streaming writers do not hang on dead connections.
+- Runtime health modules report `/ready` as `starting` with HTTP 503 until bootstrap marks them ready, and they return to `starting` as soon as application/context shutdown begins, including failed shutdown attempts.
 - Signal-driven shutdown helpers preserve bounded drain semantics, log timeout/failure conditions, and set `process.exitCode` when shutdown does not finish cleanly, but they leave final process termination ownership to the surrounding host runtime.
+- Platform snapshot production stays in runtime; graph viewing and Mermaid rendering are Studio-owned contracts consumed by CLI and automation callers.
 
 ## Public API Overview
 
@@ -134,6 +143,7 @@ class UsersModule {}
 - `Application`: Extends `ApplicationContext` with `listen()`, `dispatch()`, and `state`.
 - `ApplicationContext`: Provides `get<T>(token)`, `close()`, and access to `container` and `modules`.
 - `LifecycleHooks`: Convenience union covering `OnModuleInit`, `OnApplicationBootstrap`, `OnModuleDestroy`, and `OnApplicationShutdown`.
+- `createHealthModule(options)`: Runtime-owned `/health` and `/ready` module factory whose readiness marker follows bootstrap and shutdown lifecycle transitions.
 - `defineModule(cls, metadata)`: Programmatic module definition helper.
 - `bootstrapApplication(options)`: Lower-level async bootstrap function.
 
@@ -174,6 +184,7 @@ Lower-level Node compression internals stay behind the `@fluojs/runtime/internal
 - [@fluojs/di](../di): Dependency injection container implementation.
 - [@fluojs/http](../http): HTTP routing, controllers, and dispatcher.
 - [@fluojs/platform-nodejs](../platform-nodejs): Official Node.js HTTP adapter.
+- [@fluojs/studio](../studio): Viewer and rendering helpers for runtime-produced snapshots.
 
 ## Example Sources
 

package/dist/adapters/request-response-factory.d.ts

@@ -1,11 +1,14 @@
 import type { Dispatcher, FrameworkRequest, FrameworkResponse } from '@fluojs/http';
+/** Request/response factory seam used by shared HTTP adapter dispatch helpers. */
 export interface RequestResponseFactory<RawRequest, RawResponse, Response extends FrameworkResponse = FrameworkResponse> {
     createRequest(rawRequest: RawRequest, signal: AbortSignal): Promise<FrameworkRequest>;
     createRequestSignal(rawResponse: RawResponse): AbortSignal;
     createResponse(rawResponse: RawResponse, rawRequest: RawRequest): Response;
+    materializeRequest?(request: FrameworkRequest): Promise<void>;
     resolveRequestId(rawRequest: RawRequest): string | undefined;
     writeErrorResponse(error: unknown, response: Response, requestId?: string): Promise<void>;
 }
+/** Options for dispatching one raw platform request through a request/response factory. */
 export interface DispatchWithRequestResponseFactoryOptions<RawRequest, RawResponse, Response extends FrameworkResponse = FrameworkResponse> {
     dispatcher?: Dispatcher;
     dispatcherNotReadyMessage: string;
@@ -13,5 +16,11 @@ export interface DispatchWithRequestResponseFactoryOptions<RawRequest, RawRespon
     rawRequest: RawRequest;
     rawResponse: RawResponse;
 }
+/**
+ * Dispatches one raw platform request through the shared request/response factory lifecycle.
+ *
+ * @param options - Factory, dispatcher, and raw platform request/response values for one dispatch.
+ * @returns The framework response after dispatch, error serialization, or default finalization.
+ */
 export declare function dispatchWithRequestResponseFactory<RawRequest, RawResponse, Response extends FrameworkResponse = FrameworkResponse>({ dispatcher, dispatcherNotReadyMessage, factory, rawRequest, rawResponse, }: DispatchWithRequestResponseFactoryOptions<RawRequest, RawResponse, Response>): Promise<Response>;
 //# sourceMappingURL=request-response-factory.d.ts.map

package/dist/adapters/request-response-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-response-factory.d.ts","sourceRoot":"","sources":["../../src/adapters/request-response-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEpF,MAAM,WAAW,sBAAsB,CACrC,UAAU,EACV,WAAW,EACX,QAAQ,SAAS,iBAAiB,GAAG,iBAAiB;IAEtD,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACtF,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,WAAW,CAAC;IAC3D,cAAc,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC3E,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC;IAC7D,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3F;AAED,MAAM,WAAW,yCAAyC,CACxD,UAAU,EACV,WAAW,EACX,QAAQ,SAAS,iBAAiB,GAAG,iBAAiB;IAEtD,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,yBAAyB,EAAE,MAAM,CAAC;IAClC,OAAO,EAAE,sBAAsB,CAAC,UAAU,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;IACnE,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,wBAAsB,kCAAkC,CACtD,UAAU,EACV,WAAW,EACX,QAAQ,SAAS,iBAAiB,GAAG,iBAAiB,EACtD,EACA,UAAU,EACV,yBAAyB,EACzB,OAAO,EACP,UAAU,EACV,WAAW,GACZ,EAAE,yCAAyC,CAAC,UAAU,EAAE,WAAW,EAAE,QAAQ,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CA0BlG"}
+{"version":3,"file":"request-response-factory.d.ts","sourceRoot":"","sources":["../../src/adapters/request-response-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEpF,kFAAkF;AAClF,MAAM,WAAW,sBAAsB,CACrC,UAAU,EACV,WAAW,EACX,QAAQ,SAAS,iBAAiB,GAAG,iBAAiB;IAEtD,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACtF,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,WAAW,CAAC;IAC3D,cAAc,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC3E,kBAAkB,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC;IAC7D,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3F;AAED,2FAA2F;AAC3F,MAAM,WAAW,yCAAyC,CACxD,UAAU,EACV,WAAW,EACX,QAAQ,SAAS,iBAAiB,GAAG,iBAAiB;IAEtD,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,yBAAyB,EAAE,MAAM,CAAC;IAClC,OAAO,EAAE,sBAAsB,CAAC,UAAU,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;IACnE,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAsB,kCAAkC,CACtD,UAAU,EACV,WAAW,EACX,QAAQ,SAAS,iBAAiB,GAAG,iBAAiB,EACtD,EACA,UAAU,EACV,yBAAyB,EACzB,OAAO,EACP,UAAU,EACV,WAAW,GACZ,EAAE,yCAAyC,CAAC,UAAU,EAAE,WAAW,EAAE,QAAQ,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CA2BlG"}

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

@@ -1,3 +1,13 @@
+/** Request/response factory seam used by shared HTTP adapter dispatch helpers. */
+
+/** Options for dispatching one raw platform request through a request/response factory. */
+
+/**
+ * Dispatches one raw platform request through the shared request/response factory lifecycle.
+ *
+ * @param options - Factory, dispatcher, and raw platform request/response values for one dispatch.
+ * @returns The framework response after dispatch, error serialization, or default finalization.
+ */
 export async function dispatchWithRequestResponseFactory({
   dispatcher,
   dispatcherNotReadyMessage,
@@ -9,6 +19,7 @@ export async function dispatchWithRequestResponseFactory({
   const signal = factory.createRequestSignal(rawResponse);
   try {
     const frameworkRequest = await factory.createRequest(rawRequest, signal);
+    await factory.materializeRequest?.(frameworkRequest);
     if (!dispatcher) {
       throw new Error(dispatcherNotReadyMessage);
     }

package/dist/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EACV,kBAAkB,EAClB,WAAW,EAEX,uBAAuB,EAGvB,2BAA2B,EAC3B,sBAAsB,EACtB,eAAe,EAEf,wBAAwB,EACxB,+BAA+B,EAC/B,yBAAyB,EAEzB,gBAAgB,EAChB,UAAU,EAKX,MAAM,YAAY,CAAC;AAoTpB;;;;;;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,CA0B7G;AAkgBD;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,WAAW,CAAC,CA8GrG;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;IA6F9B;;;;;;;;OAQG;WACU,kBAAkB,CAC7B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,uBAAuB,CAAC;CAuBpC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,oBAAc,CAAC"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AAoBA,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,EAKX,MAAM,YAAY,CAAC;AA2apB;;;;;;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;AA4pBD;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,WAAW,CAAC,CAqHrG;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;IAoG9B;;;;;;;;OAQG;WACU,kBAAkB,CAC7B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,uBAAuB,CAAC;CAuBpC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,oBAAc,CAAC"}

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 {
@@ -156,44 +158,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 +324,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 +348,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 +362,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);
   }
 
   /**
@@ -363,6 +442,7 @@ class FluoApplication {
         adapter: this.adapter,
         container: this.container,
         lifecycleInstances: this.lifecycleInstances,
+        modules: this.modules,
         runtimeCleanup: this.runtimeCleanup,
         signal
       });
@@ -380,16 +460,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 +489,7 @@ class FluoApplicationContext {
       await closeRuntimeResources({
         container: this.container,
         lifecycleInstances: this.lifecycleInstances,
+        modules: this.modules,
         runtimeCleanup: this.runtimeCleanup,
         signal
       });
@@ -488,22 +575,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 +778,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);
@@ -654,6 +832,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() {},
@@ -689,8 +868,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 +899,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 +945,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;
@@ -794,8 +976,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 +999,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'
       });

package/dist/module-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-graph.d.ts","sourceRoot":"","sources":["../src/module-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAK1C,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAoB,UAAU,EAAE,MAAM,YAAY,CAAC;AAEvG;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAMvD;AAyDD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,GAAE,QAAQ,EAAO,GAAG,GAAG,CAAC,KAAK,CAAC,CAE5E;AAyTD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,GAAE,sBAA2B,GAAG,cAAc,EAAE,CASjH"}
+{"version":3,"file":"module-graph.d.ts","sourceRoot":"","sources":["../src/module-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAK1C,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAoB,UAAU,EAAE,MAAM,YAAY,CAAC;AAEvG;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAMvD;AAyDD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,GAAE,QAAQ,EAAO,GAAG,GAAG,CAAC,KAAK,CAAC,CAE5E;AA8UD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,GAAE,sBAA2B,GAAG,cAAc,EAAE,CASjH"}