@fluojs/runtime 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fluo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.ko.md

@@ -0,0 +1,182 @@
+# @fluojs/runtime
+
+<p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+
+모듈 그래프를 컴파일하고 DI와 HTTP를 실행 가능한 애플리케이션 셸로 연결하는 어셈블리 레이어입니다.
+
+## 목차
+
+- [설치](#설치)
+- [사용 시점](#사용-시점)
+- [퀵 스타트](#퀵-스타트)
+- [주요 패턴](#주요-패턴)
+- [동작 계약](#동작-계약)
+- [공개 API 개요](#공개-api-개요)
+- [관련 패키지](#관련-패키지)
+- [예제 소스](#예제-소스)
+
+## 설치
+
+```bash
+npm install @fluojs/runtime
+```
+
+## 사용 시점
+
+다음과 같은 경우에 이 패키지를 사용합니다:
+- **fluo 애플리케이션 부트스트랩**: 모듈을 실행 중인 HTTP 서버나 마이크로서비스로 변환할 때.
+- **DI 및 라이프사이클 오케스트레이션**: 모듈 그래프 컴파일, 프로바이더 연결 및 애플리케이션 훅(`onModuleInit`, `onApplicationBootstrap`)을 관리할 때.
+- **독립형 컨텍스트 생성**: HTTP 서버는 필요 없지만 DI가 필요한 CLI 태스크, 마이그레이션 또는 워커를 실행할 때.
+- **진단 및 검사**: 기계 읽기 가능한 형태나 Mermaid 기반의 모듈 그래프 토폴로지를 내보낼 때.
+
+## 퀵 스타트
+
+### 최소 HTTP 애플리케이션
+
+`fluoFactory`는 애플리케이션 생성을 위한 주요 진입점입니다.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { Controller, Get } from '@fluojs/http';
+import { fluoFactory } from '@fluojs/runtime';
+import { createNodejsAdapter } from '@fluojs/platform-nodejs';
+
+@Controller('/')
+class AppController {
+  @Get()
+  index() {
+    return { hello: 'world' };
+  }
+}
+
+@Module({
+  controllers: [AppController],
+})
+class AppModule {}
+
+// 애플리케이션 생성 및 시작
+const app = await fluoFactory.create(AppModule, {
+  adapter: createNodejsAdapter({ port: 3000 }),
+});
+
+await app.listen();
+```
+
+## 주요 패턴
+
+### 애플리케이션 컨텍스트 (HTTP 제외)
+
+백그라운드 워커나 스크립트의 경우, `createApplicationContext`를 사용하여 HTTP 설정을 건너뛸 수 있습니다.
+
+```typescript
+import { fluoFactory } from '@fluojs/runtime';
+
+const context = await fluoFactory.createApplicationContext(AppModule);
+
+// 컨테이너에서 직접 서비스 해석
+const userService = await context.get(UserService);
+await userService.doWork();
+
+await context.close();
+```
+
+### 전역 예외 필터
+
+부트스트랩 시 필터를 등록하여 횡단 관심사 에러를 처리합니다.
+
+```typescript
+import { fluoFactory, type ExceptionFilterHandler } from '@fluojs/runtime';
+
+class GlobalErrorFilter implements ExceptionFilterHandler {
+  async catch(error, { response }) {
+    console.error('에러 발생:', error);
+    response.setStatus(500);
+    void response.send({ error: 'Internal Server Error' });
+    return true; // 처리됨으로 표시
+  }
+}
+
+const app = await fluoFactory.create(AppModule, {
+  adapter: createNodejsAdapter({ port: 3000 }),
+  filters: [new GlobalErrorFilter()],
+});
+```
+
+### 모듈 구성
+
+fluo는 엄격한 모듈 그래프를 사용합니다. 모듈은 다른 모듈에서 사용할 프로바이더를 `export`를 통해 명시적으로 공개해야 합니다.
+
+```typescript
+@Module({
+  providers: [DatabaseService],
+  exports: [DatabaseService], // 외부에서 사용 가능하도록 설정
+})
+class DatabaseModule {}
+
+@Module({
+  imports: [DatabaseModule],
+  providers: [UsersService], // 이제 DatabaseService를 주입받을 수 있음
+})
+class UsersModule {}
+```
+
+## 동작 계약
+
+- 요청 바디 파싱은 Web 표준 요청과 Node 기반 요청 모두에서 바이트가 스트리밍되는 동안 `maxBodySize`를 강제합니다.
+- 멀티파트 파싱은 누적 바디 크기가 설정된 `multipart.maxTotalSize`를 넘으면 즉시 거부되며, 런타임 어댑터는 별도 재정의가 없으면 이 한도를 `maxBodySize`와 동일하게 맞춥니다.
+- 응답 스트림 백프레셔 헬퍼는 `drain`, `close`, `error` 중 어느 경우에도 `waitForDrain()`을 완료시켜 끊어진 연결에서 스트리밍 작성기가 멈추지 않도록 합니다.
+- 시그널 기반 종료 헬퍼는 bounded drain semantics를 유지하면서 timeout/실패 상황을 로그와 `process.exitCode`로 보고하지만, 최종 프로세스 종료 소유권은 주변 호스트 런타임에 남겨 둡니다.
+
+## 공개 API 개요
+
+- `fluoFactory`: 패키지 예제에서 사용하는 런타임 부트스트랩 파사드의 lower-camel-case 별칭입니다.
+- `FluoFactory`: 호환성과 명시적 static 접근을 위해 유지되는 클래스 기반 런타임 부트스트랩 파사드입니다.
+- `Application`: `ApplicationContext`를 확장하며 `listen()`, `dispatch()`, `state`를 포함합니다.
+- `ApplicationContext`: `get<T>(token)`, `close()` 기능을 제공하며 `container`와 `modules`에 접근할 수 있습니다.
+- `LifecycleHooks`: `OnModuleInit`, `OnApplicationBootstrap`, `OnModuleDestroy`, `OnApplicationShutdown`를 묶는 편의 union 타입입니다.
+- `defineModule(cls, metadata)`: 프로그래밍 방식의 모듈 정의 헬퍼입니다.
+- `bootstrapApplication(options)`: 저수준 비동기 부트스트랩 함수입니다.
+
+## 플랫폼 전용 서브경로
+
+| 서브경로 | 용도 |
+| :--- | :--- |
+| `@fluojs/runtime/node` | 로거 팩토리, Node 어댑터/부트스트랩 헬퍼, 종료 시그널 등록을 위한 지원되는 Node.js 전용 진입점입니다. |
+| `@fluojs/runtime/web` | Bun, Deno, Cloudflare Workers를 위한 공유 웹 표준 요청/응답 유틸리티. |
+| `@fluojs/runtime/internal` | 저수준 오케스트레이션 헬퍼 및 HTTP 어댑터 기본 로직. |
+| `@fluojs/runtime/internal-node` | 어댑터/패키지 호환 계층이 사용하는 Node 전용 내부 seam이며, 애플리케이션 코드에서는 `@fluojs/runtime/node`를 우선 사용하세요. |
+
+### Node 전용 서브경로 (`@fluojs/runtime/node`)
+
+로거 팩토리와 지원되는 기타 Node 전용 헬퍼는 범용 루트 진입점에 포함되지 않습니다. `./node` 서브경로에서 가져오세요:
+
+```typescript
+import {
+  bootstrapNodeApplication,
+  createConsoleApplicationLogger,
+  createJsonApplicationLogger,
+  createNodeHttpAdapter,
+  runNodeApplication,
+} from '@fluojs/runtime/node';
+```
+
+- `createConsoleApplicationLogger()`: `process.stdout`/`process.stderr`를 사용하는 컬러 콘솔 로거.
+- `createJsonApplicationLogger()`: `process.stdout`/`process.stderr`를 사용하는 구조화된 JSON 로거.
+- `createNodeHttpAdapter()`: 어댑터 우선 런타임 구성을 위한 raw Node `http`/`https` 어댑터 팩토리.
+- `bootstrapNodeApplication()` / `runNodeApplication()`: 호환 패키지와 직접 Node 런타임 흐름에서 사용하는 Node 전용 부트스트랩 헬퍼.
+- `createNodeShutdownSignalRegistration()`, `defaultNodeShutdownSignals()`, `registerShutdownSignals()`: 호스트가 명시적으로 시그널 wiring을 제어할 때 쓰는 종료 등록 헬퍼.
+
+더 저수준의 Node compression internals는 공개 `@fluojs/runtime/node` 계약이 아니라 `@fluojs/runtime/internal-node` seam 뒤에 둡니다.
+
+## 관련 패키지
+
+- [@fluojs/core](../core): 핵심 데코레이터 및 메타데이터 시스템.
+- [@fluojs/di](../di): 의존성 주입(DI) 컨테이너 구현체.
+- [@fluojs/http](../http): HTTP 라우팅, 컨트롤러 및 디스패처.
+- [@fluojs/platform-nodejs](../platform-nodejs): 공식 Node.js HTTP 어댑터.
+
+## 예제 소스
+
+- [examples/minimal](../../examples/minimal): 최소한의 부트스트랩 예제.
+- [examples/realworld-api](../../examples/realworld-api): 복잡한 모듈 연결이 포함된 전체 애플리케이션 예제.
+- [packages/runtime/src/bootstrap.test.ts](./src/bootstrap.test.ts): 부트스트랩 단계별 동작 테스트.

package/README.md

@@ -0,0 +1,182 @@
+# @fluojs/runtime
+
+<p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+
+The assembly layer that compiles a module graph and wires DI and HTTP into a runnable application shell.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [When to Use](#when-to-use)
+- [Quick Start](#quick-start)
+- [Common Patterns](#common-patterns)
+- [Behavioral Contracts](#behavioral-contracts)
+- [Public API Overview](#public-api-overview)
+- [Related Packages](#related-packages)
+- [Example Sources](#example-sources)
+
+## Installation
+
+```bash
+npm install @fluojs/runtime
+```
+
+## When to Use
+
+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.
+
+## Quick Start
+
+### Minimal HTTP Application
+
+The `fluoFactory` is the primary entrypoint for creating applications.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { Controller, Get } from '@fluojs/http';
+import { fluoFactory } from '@fluojs/runtime';
+import { createNodejsAdapter } from '@fluojs/platform-nodejs';
+
+@Controller('/')
+class AppController {
+  @Get()
+  index() {
+    return { hello: 'world' };
+  }
+}
+
+@Module({
+  controllers: [AppController],
+})
+class AppModule {}
+
+// Create and start the application
+const app = await fluoFactory.create(AppModule, {
+  adapter: createNodejsAdapter({ port: 3000 }),
+});
+
+await app.listen();
+```
+
+## Common Patterns
+
+### Application Context (No HTTP)
+
+For background workers or scripts, use `createApplicationContext` to skip HTTP setup.
+
+```typescript
+import { fluoFactory } from '@fluojs/runtime';
+
+const context = await fluoFactory.createApplicationContext(AppModule);
+
+// Resolve a service directly from the container
+const userService = await context.get(UserService);
+await userService.doWork();
+
+await context.close();
+```
+
+### Global Exception Filters
+
+Handle cross-cutting errors by registering filters during bootstrap.
+
+```typescript
+import { fluoFactory, type ExceptionFilterHandler } from '@fluojs/runtime';
+
+class GlobalErrorFilter implements ExceptionFilterHandler {
+  async catch(error, { response }) {
+    console.error('Caught error:', error);
+    response.setStatus(500);
+    void response.send({ error: 'Internal Server Error' });
+    return true; // Mark as handled
+  }
+}
+
+const app = await fluoFactory.create(AppModule, {
+  adapter: createNodejsAdapter({ port: 3000 }),
+  filters: [new GlobalErrorFilter()],
+});
+```
+
+### Module Composition
+
+fluo uses a strict module graph. Modules must explicitly `export` providers to make them available to `importing` modules.
+
+```typescript
+@Module({
+  providers: [DatabaseService],
+  exports: [DatabaseService], // Make it available outside
+})
+class DatabaseModule {}
+
+@Module({
+  imports: [DatabaseModule],
+  providers: [UsersService], // Can now inject DatabaseService
+})
+class UsersModule {}
+```
+
+## Behavioral Contracts
+
+- Request body parsing enforces `maxBodySize` while bytes are still streaming for both Web-standard and Node-backed requests.
+- 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.
+- 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.
+
+## Public API Overview
+
+- `fluoFactory`: Lower-camel-case alias for the runtime bootstrap facade used in the package examples.
+- `FluoFactory`: Class-based runtime bootstrap facade retained for compatibility and explicit static access.
+- `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`.
+- `defineModule(cls, metadata)`: Programmatic module definition helper.
+- `bootstrapApplication(options)`: Lower-level async bootstrap function.
+
+## Platform-Specific Subpaths
+
+| Subpath | Purpose |
+| :--- | :--- |
+| `@fluojs/runtime/node` | Supported Node.js entrypoint for logger factories, Node adapter/bootstrap helpers, and shutdown signal registration. |
+| `@fluojs/runtime/web` | Shared Web-standard request/response utilities for Bun, Deno, and Cloudflare Workers. |
+| `@fluojs/runtime/internal` | Low-level orchestration helpers and HTTP adapter base logic. |
+| `@fluojs/runtime/internal-node` | Node-only internal seam used by adapter/package compatibility layers; prefer `@fluojs/runtime/node` in application code. |
+
+### Node-Specific Subpath (`@fluojs/runtime/node`)
+
+Logger factories and other supported Node-only helpers are **not** on the universal root entrypoint. Import them from the `./node` subpath:
+
+```typescript
+import {
+  bootstrapNodeApplication,
+  createConsoleApplicationLogger,
+  createJsonApplicationLogger,
+  createNodeHttpAdapter,
+  runNodeApplication,
+} from '@fluojs/runtime/node';
+```
+
+- `createConsoleApplicationLogger()`: Colorized console logger using `process.stdout`/`process.stderr`.
+- `createJsonApplicationLogger()`: Structured JSON logger using `process.stdout`/`process.stderr`.
+- `createNodeHttpAdapter()`: Raw Node `http`/`https` adapter factory for adapter-first runtime setup.
+- `bootstrapNodeApplication()` / `runNodeApplication()`: Node-specific bootstrap helpers used by compatibility packages and direct Node runtime flows.
+- `createNodeShutdownSignalRegistration()`, `defaultNodeShutdownSignals()`, `registerShutdownSignals()`: Shutdown registration helpers for hosts that need explicit signal wiring.
+
+Lower-level Node compression internals stay behind the `@fluojs/runtime/internal-node` seam rather than the public `@fluojs/runtime/node` contract.
+
+## Related Packages
+
+- [@fluojs/core](../core): Core decorators and metadata system.
+- [@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.
+
+## Example Sources
+
+- [examples/minimal](../../examples/minimal): Smallest possible bootstrap.
+- [examples/realworld-api](../../examples/realworld-api): Full application with complex module wiring.
+- [packages/runtime/src/bootstrap.test.ts](./src/bootstrap.test.ts): Behavioral tests for bootstrap phases.

package/dist/abort.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Races a promise-returning function against an AbortSignal.
+ * Rejects immediately if the signal is already aborted, or rejects as soon
+ * as the signal fires while `fn` is still pending.
+ *
+ * @param fn Async operation to execute while observing the abort signal.
+ * @param signal Abort signal that can cancel the in-flight operation.
+ * @returns The resolved value from `fn` when no abort happens first.
+ * @throws {Error} An `AbortError` when the signal is already aborted or aborts before `fn` settles.
+ */
+export declare function raceWithAbort<T>(fn: () => Promise<T>, signal: AbortSignal): Promise<T>;
+/**
+ * Normalises an abort reason into an `Error` with `name = 'AbortError'`.
+ *
+ * @param reason Abort reason attached to the triggering `AbortSignal`.
+ * @returns A normalized `Error` instance with `name` set to `AbortError`.
+ */
+export declare function createAbortError(reason: unknown): Error;
+//# sourceMappingURL=abort.d.ts.map

package/dist/abort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort.d.ts","sourceRoot":"","sources":["../src/abort.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAgB5F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,GAAG,KAAK,CAKvD"}

package/dist/abort.js

@@ -0,0 +1,39 @@
+/**
+ * Races a promise-returning function against an AbortSignal.
+ * Rejects immediately if the signal is already aborted, or rejects as soon
+ * as the signal fires while `fn` is still pending.
+ *
+ * @param fn Async operation to execute while observing the abort signal.
+ * @param signal Abort signal that can cancel the in-flight operation.
+ * @returns The resolved value from `fn` when no abort happens first.
+ * @throws {Error} An `AbortError` when the signal is already aborted or aborts before `fn` settles.
+ */
+export async function raceWithAbort(fn, signal) {
+  if (signal.aborted) {
+    throw createAbortError(signal.reason);
+  }
+  return await new Promise((resolve, reject) => {
+    const onAbort = () => {
+      reject(createAbortError(signal.reason));
+    };
+    signal.addEventListener('abort', onAbort, {
+      once: true
+    });
+    Promise.resolve(fn()).then(resolve, reject).finally(() => {
+      signal.removeEventListener('abort', onAbort);
+    });
+  });
+}
+
+/**
+ * Normalises an abort reason into an `Error` with `name = 'AbortError'`.
+ *
+ * @param reason Abort reason attached to the triggering `AbortSignal`.
+ * @returns A normalized `Error` instance with `name` set to `AbortError`.
+ */
+export function createAbortError(reason) {
+  const message = reason instanceof Error ? reason.message : 'Request aborted before response commit.';
+  const error = new Error(message);
+  error.name = 'AbortError';
+  return error;
+}

package/dist/adapters/internal-http-adapter.d.ts

@@ -0,0 +1,2 @@
+export { bootstrapHttpAdapterApplication, createHttpAdapterMiddleware, formatHttpAdapterListenMessage, runHttpAdapterApplication, type BootstrapHttpAdapterApplicationOptions, type HttpAdapterCorsInput, type HttpAdapterListenTarget, type HttpAdapterMiddlewareOptions, type HttpAdapterShutdownRegistration, type RunHttpAdapterApplicationOptions, } from '../http-adapter-shared.js';
+//# sourceMappingURL=internal-http-adapter.d.ts.map

package/dist/adapters/internal-http-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-http-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/internal-http-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,EAC/B,2BAA2B,EAC3B,8BAA8B,EAC9B,yBAAyB,EACzB,KAAK,sCAAsC,EAC3C,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,gCAAgC,GACtC,MAAM,2BAA2B,CAAC"}

package/dist/adapters/internal-http-adapter.js

@@ -0,0 +1 @@
+export { bootstrapHttpAdapterApplication, createHttpAdapterMiddleware, formatHttpAdapterListenMessage, runHttpAdapterApplication } from '../http-adapter-shared.js';

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

@@ -0,0 +1,2 @@
+export { dispatchWithRequestResponseFactory, type DispatchWithRequestResponseFactoryOptions, type RequestResponseFactory, } from './request-response-factory.js';
+//# sourceMappingURL=internal-request-response-factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"internal-request-response-factory.d.ts","sourceRoot":"","sources":["../../src/adapters/internal-request-response-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kCAAkC,EAClC,KAAK,yCAAyC,EAC9C,KAAK,sBAAsB,GAC5B,MAAM,+BAA+B,CAAC"}

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

@@ -0,0 +1 @@
+export { dispatchWithRequestResponseFactory } from './request-response-factory.js';

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

@@ -0,0 +1,17 @@
+import type { Dispatcher, FrameworkRequest, FrameworkResponse } from '@fluojs/http';
+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;
+    resolveRequestId(rawRequest: RawRequest): string | undefined;
+    writeErrorResponse(error: unknown, response: Response, requestId?: string): Promise<void>;
+}
+export interface DispatchWithRequestResponseFactoryOptions<RawRequest, RawResponse, Response extends FrameworkResponse = FrameworkResponse> {
+    dispatcher?: Dispatcher;
+    dispatcherNotReadyMessage: string;
+    factory: RequestResponseFactory<RawRequest, RawResponse, Response>;
+    rawRequest: RawRequest;
+    rawResponse: RawResponse;
+}
+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

@@ -0,0 +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"}

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

@@ -0,0 +1,27 @@
+export async function dispatchWithRequestResponseFactory({
+  dispatcher,
+  dispatcherNotReadyMessage,
+  factory,
+  rawRequest,
+  rawResponse
+}) {
+  const frameworkResponse = factory.createResponse(rawResponse, rawRequest);
+  const signal = factory.createRequestSignal(rawResponse);
+  try {
+    const frameworkRequest = await factory.createRequest(rawRequest, signal);
+    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;
+  }
+}

package/dist/bootstrap.d.ts

@@ -0,0 +1,73 @@
+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;
+/**
+ * Bootstraps the module graph and returns the root container baseline.
+ *
+ * @param rootModule Root module type used as the module-graph entrypoint.
+ * @param options Bootstrap-module options such as runtime providers and duplicate-provider policy.
+ * @returns The compiled module graph and initialized DI container baseline.
+ * @throws {DuplicateProviderError} When duplicate module provider tokens are detected and policy is `throw`.
+ * @throws {Error} When module-graph compilation or provider registration fails.
+ */
+export declare function bootstrapModule(rootModule: ModuleType, options?: BootstrapModuleOptions): BootstrapResult;
+/**
+ * Creates the runtime application shell by composing bootstrap-level providers,
+ * module bootstrap, and lifecycle hook execution.
+ *
+ * @param options Runtime bootstrap contract including root module, adapter, and global runtime hooks.
+ * @returns A fully bootstrapped `Application` shell ready for `ready()`/`listen()`.
+ * @throws {Error} Propagates module-graph, lifecycle, or runtime initialization failures.
+ */
+export declare function bootstrapApplication(options: BootstrapApplicationOptions): Promise<Application>;
+/**
+ * Canonical runtime bootstrap facade for HTTP, context-only, and microservice startup.
+ */
+export declare class FluoFactory {
+    /**
+     * Creates a full HTTP-capable application from the root module.
+     *
+     * @param rootModule Root module type used as the application composition entrypoint.
+     * @param options Optional HTTP-runtime bootstrap options.
+     * @returns A bootstrapped HTTP-capable `Application`.
+     * @throws {Error} Propagates bootstrap failures from `bootstrapApplication(...)`.
+     */
+    static create(rootModule: ModuleType, options?: CreateApplicationOptions): Promise<Application>;
+    /**
+     * Creates an application context without attaching an HTTP runtime.
+     *
+     * @param rootModule Root module type used as the context composition entrypoint.
+     * @param options Optional context bootstrap options.
+     * @returns A bootstrapped `ApplicationContext` that exposes DI and lifecycle control.
+     * @throws {Error} Propagates module-graph, lifecycle, and context bootstrap failures.
+     */
+    static createApplicationContext(rootModule: ModuleType, options?: CreateApplicationContextOptions): Promise<ApplicationContext>;
+    /**
+     * Creates a microservice application from the configured runtime token.
+     *
+     * @param rootModule Root module type used as the microservice composition entrypoint.
+     * @param options Optional microservice bootstrap options, including `microserviceToken` overrides.
+     * @returns A bootstrapped `MicroserviceApplication` wrapper around the resolved runtime transport.
+     * @throws {InvariantError} When the resolved runtime token does not implement `listen()`.
+     * @throws {Error} Propagates application-context bootstrap or runtime-resolution failures.
+     */
+    static createMicroservice(rootModule: ModuleType, options?: CreateMicroserviceOptions): Promise<MicroserviceApplication>;
+}
+/**
+ * Lower-camel-case compatibility alias that matches the documented runtime entrypoint.
+ *
+ * @example
+ * ```ts
+ * import { fluoFactory } from '@fluojs/runtime';
+ *
+ * const app = await fluoFactory.create(AppModule);
+ * ```
+ */
+export declare const fluoFactory: typeof FluoFactory;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/bootstrap.d.ts.map

@@ -0,0 +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"}