@fluojs/platform-fastify 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,160 @@
+# @fluojs/platform-fastify
+
+<p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+
+fluo 런타임을 위한 Fastify 기반 HTTP 어댑터 패키지입니다.
+
+## 목차
+
+- [설치](#설치)
+- [사용 시점](#사용-시점)
+- [빠른 시작](#빠른-시작)
+- [주요 패턴](#주요-패턴)
+- [성능](#성능)
+- [공개 API 개요](#공개-api-개요)
+- [트러블슈팅](#트러블슈팅)
+- [관련 패키지](#관련-패키지)
+- [예제 소스](#예제-소스)
+
+## 설치
+
+```bash
+npm install @fluojs/platform-fastify fastify
+```
+
+## 사용 시점
+
+fluo 애플리케이션을 위한 고성능 HTTP 어댑터가 필요한 경우 이 패키지를 사용합니다. Fastify는 낮은 오버헤드와 효율적인 요청 처리로 잘 알려져 있으며, 높은 처리량과 동시성이 요구되는 프로덕션 fluo 애플리케이션에 권장되는 선택입니다.
+
+## 빠른 시작
+
+```typescript
+import { createFastifyAdapter } from '@fluojs/platform-fastify';
+import { fluoFactory } from '@fluojs/runtime';
+import { AppModule } from './app.module';
+
+const app = await fluoFactory.create(AppModule, {
+  adapter: createFastifyAdapter({ port: 3000 }),
+});
+
+await app.listen();
+```
+
+## 주요 패턴
+
+### 멀티파트 및 Raw Body
+Fastify 어댑터는 내부 Fastify 플러그인을 통해 멀티파트 form-data 및 raw body 파싱을 기본적으로 지원하며, 이는 표준 fluo 요청 인터페이스를 통해 노출됩니다. 어댑터를 직접 생성할 때는 멀티파트 제한을 두 번째 인자로 전달하고, `bootstrapFastifyApplication(...)` 및 `runFastifyApplication(...)`에서는 같은 설정을 `options.multipart` 아래에 전달하면 됩니다.
+
+```typescript
+const adapter = createFastifyAdapter(
+  {
+    port: 3000,
+    rawBody: true,
+  },
+  {
+    maxTotalSize: 10 * 1024 * 1024,
+  },
+);
+```
+
+### 서버 기반 실시간 통신 (Real-Time)
+Fastify는 `@fluojs/websockets`가 기본 Node.js HTTP 서버에 직접 연결될 수 있도록 `server-backed` 기능을 제공합니다.
+
+```typescript
+@WebSocketGateway({ path: '/ws' })
+export class MyGateway {}
+```
+
+### CORS 설정
+CORS는 부트스트랩 옵션을 통해 처리됩니다. fluo는 별도의 Fastify 플러그인에 의존하지 않고 내부 CORS 로직을 관리합니다.
+
+```typescript
+// 단순 origin 문자열 설정
+await bootstrapFastifyApplication(AppModule, {
+  cors: 'https://my-frontend.com',
+  port: 3000,
+});
+
+// 세부 설정
+await bootstrapFastifyApplication(AppModule, {
+  cors: {
+    origin: ['https://a.com', 'https://b.com'],
+    methods: ['GET', 'POST', 'PUT', 'DELETE'],
+  },
+  port: 3000,
+});
+
+// 명시적으로 비활성화
+await bootstrapFastifyApplication(AppModule, {
+  cors: false,
+  port: 3000,
+});
+```
+
+### 글로벌 접두사 (Global Prefix)
+라우팅 접두사를 전역으로 설정하고, 헬스 체크와 같은 특정 경로는 제외할 수 있습니다.
+
+```typescript
+await bootstrapFastifyApplication(AppModule, {
+  globalPrefix: '/api',
+  globalPrefixExclude: ['/health'],
+  port: 3000,
+});
+```
+
+### 로깅 (Logging)
+fluo는 자체 로깅 시스템을 사용합니다. 어댑터는 Fastify 인스턴스를 생성할 때 네이티브 로거를 비활성화하며, 부트스트랩 옵션에 제공된 fluo 로거를 통해 로그를 기록합니다.
+
+```typescript
+await runFastifyApplication(AppModule, {
+  logger: myLogger,
+  port: 3000,
+});
+```
+
+### 미들웨어 (Middleware)
+요청이 핸들러에 도달하기 전에 실행되는 런타임 레벨의 미들웨어를 등록할 수 있습니다. 이는 Fastify 전용 플러그인이 아닌 표준 `MiddlewareLike` 함수라는 점에 유의하세요.
+
+```typescript
+await bootstrapFastifyApplication(AppModule, {
+  middleware: [myCustomMiddleware],
+  port: 3000,
+});
+```
+
+## 성능
+
+fluo의 Fastify 어댑터는 높은 동시성 시나리오에서 raw Node.js 어댑터보다 훨씬 뛰어난 성능을 발휘합니다.
+
+| 어댑터 | 초당 요청 수 (Req/sec) | 평균 지연 시간 (Avg Latency) |
+| --- | ---: | ---: |
+| Raw Node.js 어댑터 | ~31,000 | 4.0ms |
+| Fastify 어댑터 | **~58,000** | **2.1ms** |
+
+*표준 `/health` 엔드포인트에서 `wrk`를 사용하여 측정되었습니다.*
+
+## 공개 API 개요
+
+- `createFastifyAdapter(options)`: Fastify 어댑터를 위한 권장 팩토리입니다.
+- `bootstrapFastifyApplication(module, options)`: 암시적 리스닝 없이 수행하는 고급 부트스트랩입니다.
+- `runFastifyApplication(module, options)`: 생명주기 관리를 포함한 빠른 시작 헬퍼입니다. timeout/실패 시에는 해당 상태를 로그와 `process.exitCode`로 보고하고, 최종 프로세스 종료는 주변 호스트에 맡깁니다.
+- `FastifyHttpApplicationAdapter`: 핵심 어댑터 구현 클래스입니다.
+
+## 트러블슈팅
+
+- **CORS 오류**: `cors` 부트스트랩 옵션을 사용 중인지 확인하세요. Fastify의 네이티브 CORS 플러그인을 사용하지 않으므로 오직 fluo가 관리하는 CORS 로직만 적용됩니다.
+- **미들웨어 문제**: `middleware` 옵션은 런타임 레벨의 `MiddlewareLike[]` 함수 배열을 받습니다. 이는 Fastify 플러그인이 아니며 다른 fluo 어댑터들과 공통으로 사용되는 표준 인터페이스를 따릅니다.
+- **로깅 (Logging)**: 로그 스트림 중복을 방지하기 위해 Fastify의 네이티브 로거가 비활성화됩니다. 모든 로깅 설정은 `runFastifyApplication` 또는 `bootstrapFastifyApplication`의 `logger` 옵션을 통해 이루어져야 합니다.
+- **글로벌 접두사 (Global Prefix)**: 내부 경로 또는 헬스 체크 엔드포인트에 접두사가 붙지 않도록 `globalPrefixExclude`를 적절히 설정하세요.
+
+## 관련 패키지
+
+- `@fluojs/runtime`: 핵심 런타임입니다.
+- `@fluojs/platform-express`: 대안 Express 기반 어댑터입니다.
+- `@fluojs/websockets`: 실시간 게이트웨이 지원을 제공합니다.
+
+## 예제 소스
+
+- `packages/platform-fastify/src/adapter.test.ts`
+- `examples/minimal/src/main.ts`
+- `examples/realworld-api/src/main.ts`

package/README.md

@@ -0,0 +1,160 @@
+# @fluojs/platform-fastify
+
+<p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+
+Fastify-backed HTTP adapter for the fluo runtime.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [When to Use](#when-to-use)
+- [Quick Start](#quick-start)
+- [Common Patterns](#common-patterns)
+- [Performance](#performance)
+- [Public API Overview](#public-api-overview)
+- [Troubleshooting](#troubleshooting)
+- [Related Packages](#related-packages)
+- [Example Sources](#example-sources)
+
+## Installation
+
+```bash
+npm install @fluojs/platform-fastify fastify
+```
+
+## When to Use
+
+Use this package when you need a high-performance HTTP adapter for your fluo application. Fastify is known for its low overhead and efficient request handling, making it the recommended choice for production fluo applications requiring high throughput and concurrency.
+
+## Quick Start
+
+```typescript
+import { createFastifyAdapter } from '@fluojs/platform-fastify';
+import { fluoFactory } from '@fluojs/runtime';
+import { AppModule } from './app.module';
+
+const app = await fluoFactory.create(AppModule, {
+  adapter: createFastifyAdapter({ port: 3000 }),
+});
+
+await app.listen();
+```
+
+## Common Patterns
+
+### Multipart and Raw Body
+The Fastify adapter includes built-in support for multipart form-data and raw body parsing via internal Fastify plugins, exposed through the standard fluo request interface. When you construct the adapter directly, pass multipart limits as the second argument. `bootstrapFastifyApplication(...)` and `runFastifyApplication(...)` accept the same multipart settings under `options.multipart`.
+
+```typescript
+const adapter = createFastifyAdapter(
+  {
+    port: 3000,
+    rawBody: true,
+  },
+  {
+    maxTotalSize: 10 * 1024 * 1024,
+  },
+);
+```
+
+### Server-Backed Real-Time
+Fastify provides a `server-backed` capability that allows `@fluojs/websockets` to attach directly to the underlying Node.js HTTP server.
+
+```typescript
+@WebSocketGateway({ path: '/ws' })
+export class MyGateway {}
+```
+
+### CORS Configuration
+CORS is handled via bootstrap options. fluo manages the underlying CORS logic rather than relying on a separate Fastify plugin.
+
+```typescript
+// Simple origin string
+await bootstrapFastifyApplication(AppModule, {
+  cors: 'https://my-frontend.com',
+  port: 3000,
+});
+
+// Fine-grained control
+await bootstrapFastifyApplication(AppModule, {
+  cors: {
+    origin: ['https://a.com', 'https://b.com'],
+    methods: ['GET', 'POST', 'PUT', 'DELETE'],
+  },
+  port: 3000,
+});
+
+// Explicitly disabled
+await bootstrapFastifyApplication(AppModule, {
+  cors: false,
+  port: 3000,
+});
+```
+
+### Global Prefix
+Configure a global routing prefix and exclude specific paths like health checks.
+
+```typescript
+await bootstrapFastifyApplication(AppModule, {
+  globalPrefix: '/api',
+  globalPrefixExclude: ['/health'],
+  port: 3000,
+});
+```
+
+### Logging
+fluo uses its own logging system. The adapter creates the Fastify instance with its native logger disabled and pipes through the fluo logger provided in the bootstrap options.
+
+```typescript
+await runFastifyApplication(AppModule, {
+  logger: myLogger,
+  port: 3000,
+});
+```
+
+### Middleware
+You can register runtime-level middleware that runs before the request reaches the handlers. Note that these are standard `MiddlewareLike` functions, not Fastify-specific plugins.
+
+```typescript
+await bootstrapFastifyApplication(AppModule, {
+  middleware: [myCustomMiddleware],
+  port: 3000,
+});
+```
+
+## Performance
+
+fluo's Fastify adapter significantly outperforms the raw Node.js adapter in high-concurrency scenarios.
+
+| Adapter | Requests/sec | Avg Latency |
+| --- | ---: | ---: |
+| Raw Node.js Adapter | ~31,000 | 4.0ms |
+| Fastify Adapter | **~58,000** | **2.1ms** |
+
+*Measured using `wrk` on a standard `/health` endpoint.*
+
+## Public API Overview
+
+- `createFastifyAdapter(options)`: Recommended factory for the Fastify adapter.
+- `bootstrapFastifyApplication(module, options)`: advanced bootstrap without implicit listening.
+- `runFastifyApplication(module, options)`: Quick-start helper with lifecycle management. On timeout/failure it reports the condition through logging and `process.exitCode`, while leaving final process termination to the surrounding host.
+- `FastifyHttpApplicationAdapter`: The core adapter implementation.
+
+## Troubleshooting
+
+- **CORS Errors**: Ensure you're using the `cors` bootstrap option. Since Fastify's native CORS plugin is not registered, only the fluo-managed CORS logic applies.
+- **Middleware Issues**: The `middleware` option accepts runtime-level `MiddlewareLike[]` functions. These are not Fastify plugins and follow the standard middleware interface used across fluo adapters.
+- **Logging**: The native Fastify logger is disabled to prevent duplicate log streams. All logging should be configured via the fluo `logger` option in `runFastifyApplication` or `bootstrapFastifyApplication`.
+- **Global Prefix**: Use `globalPrefixExclude` to prevent the prefix from being applied to internal routes or health check endpoints.
+
+## Related Packages
+
+- `@fluojs/runtime`: Core framework runtime.
+- `@fluojs/platform-express`: Alternative Express-based adapter.
+- `@fluojs/websockets`: Real-time gateway support.
+
+## Example Sources
+
+- `packages/platform-fastify/src/adapter.test.ts`
+- `examples/minimal/src/main.ts`
+- `examples/realworld-api/src/main.ts`

package/dist/adapter.d.ts

@@ -0,0 +1,132 @@
+import type { ServerOptions as HttpsServerOptions } from 'node:https';
+import { type CorsOptions, type Dispatcher, type HttpApplicationAdapter, type MiddlewareLike, type SecurityHeadersOptions } from '@fluojs/http';
+import { type Application, type ApplicationLogger, type CreateApplicationOptions, type ModuleType, type MultipartOptions, type UploadedFile } from '@fluojs/runtime';
+declare module '@fluojs/http' {
+    interface FrameworkRequest {
+        files?: UploadedFile[];
+        rawBody?: Uint8Array;
+    }
+}
+/**
+ * Transport-level knobs for the standalone Fastify HTTP adapter factory.
+ */
+export interface FastifyAdapterOptions {
+    host?: string;
+    https?: HttpsServerOptions;
+    maxBodySize?: number;
+    port?: number;
+    rawBody?: boolean;
+    retryDelayMs?: number;
+    retryLimit?: number;
+    shutdownTimeoutMs?: number;
+}
+/** Node.js shutdown signals supported by `runFastifyApplication(...)`. */
+export type FastifyApplicationSignal = 'SIGINT' | 'SIGTERM';
+/** CORS shorthand accepted by the Fastify runtime bootstrap helpers. */
+export type CorsInput = false | string | string[] | CorsOptions;
+/**
+ * Bootstrap options for creating a Fastify-backed application without
+ * implicitly registering process shutdown listeners.
+ */
+export interface BootstrapFastifyApplicationOptions extends Omit<CreateApplicationOptions, 'adapter' | 'logger' | 'middleware'> {
+    cors?: CorsInput;
+    globalPrefix?: string;
+    globalPrefixExclude?: readonly string[];
+    host?: string;
+    https?: HttpsServerOptions;
+    logger?: ApplicationLogger;
+    maxBodySize?: number;
+    middleware?: MiddlewareLike[];
+    multipart?: MultipartOptions;
+    port?: number;
+    rawBody?: boolean;
+    retryDelayMs?: number;
+    retryLimit?: number;
+    securityHeaders?: false | SecurityHeadersOptions;
+    shutdownTimeoutMs?: number;
+}
+/**
+ * Bootstrap options for `runFastifyApplication(...)`, including shutdown hooks.
+ */
+export interface RunFastifyApplicationOptions extends BootstrapFastifyApplicationOptions {
+    forceExitTimeoutMs?: number;
+    shutdownSignals?: false | readonly FastifyApplicationSignal[];
+}
+interface FastifyListenTarget {
+    bindTarget: string;
+    url: string;
+}
+/**
+ * Fastify-backed `HttpApplicationAdapter` implementation used by the runtime.
+ *
+ * It preserves the shared Fluo dispatcher contract while exposing Fastify's
+ * server-backed realtime capability and multipart/raw-body integrations.
+ */
+export declare class FastifyHttpApplicationAdapter implements HttpApplicationAdapter {
+    private readonly port;
+    private readonly host;
+    private readonly retryDelayMs;
+    private readonly retryLimit;
+    private readonly httpsOptions;
+    private readonly multipartOptions?;
+    private readonly maxBodySize;
+    private readonly preserveRawBody;
+    private readonly shutdownTimeoutMs;
+    private closeInFlight?;
+    private dispatcher?;
+    private pluginsReady;
+    private readonly app;
+    private readonly requestResponseFactory;
+    constructor(port: number, host: string | undefined, retryDelayMs: number | undefined, retryLimit: number | undefined, httpsOptions: HttpsServerOptions | undefined, multipartOptions?: MultipartOptions | undefined, maxBodySize?: number, preserveRawBody?: boolean, shutdownTimeoutMs?: number);
+    getServer(): unknown;
+    getRealtimeCapability(): import("@fluojs/http").ServerBackedHttpAdapterRealtimeCapability;
+    getListenTarget(): FastifyListenTarget;
+    listen(dispatcher: Dispatcher): Promise<void>;
+    close(): Promise<void>;
+    private registerPluginsAndRoute;
+    private listenWithRetry;
+    private handleRequest;
+}
+/**
+ * Create the recommended Fastify adapter for `FluoFactory.create(...)`.
+ *
+ * @example
+ * ```ts
+ * const app = await FluoFactory.create(AppModule, {
+ *   adapter: createFastifyAdapter({ port: 3000 }),
+ * });
+ * ```
+ *
+ * @param options Transport-level Fastify settings such as host, port, retries, and raw-body preservation.
+ * @param multipartOptions Optional multipart parsing limits exposed through `FrameworkRequest.files`.
+ * @returns A runtime `HttpApplicationAdapter` backed by Fastify.
+ */
+export declare function createFastifyAdapter(options?: FastifyAdapterOptions, multipartOptions?: MultipartOptions): HttpApplicationAdapter;
+/**
+ * Bootstrap a Fastify-backed application without implicitly calling `listen()`.
+ *
+ * @param rootModule Root application module compiled by the Fluo runtime.
+ * @param options Runtime, middleware, and Fastify adapter settings.
+ * @returns An initialized application shell that can be listened to later.
+ */
+export declare function bootstrapFastifyApplication(rootModule: ModuleType, options: BootstrapFastifyApplicationOptions): Promise<Application>;
+/**
+ * Bootstrap and prepare a Fastify-backed application with shutdown registration.
+ *
+ * This helper mirrors the README quick-start path: create the adapter, wire the
+ * runtime, and attach signal handling so callers only need to invoke `listen()`.
+ *
+ * @param rootModule Root application module compiled by the Fluo runtime.
+ * @param options Runtime, adapter, and shutdown registration settings.
+ * @returns A bootstrapped application shell ready to listen.
+ */
+export declare function runFastifyApplication(rootModule: ModuleType, options: RunFastifyApplicationOptions): Promise<Application>;
+/**
+ * Detect whether a thrown Fastify multipart error maps to payload-too-large semantics.
+ *
+ * @param error Unknown Fastify or plugin error thrown while parsing multipart input.
+ * @returns `true` when the error should surface as `PayloadTooLargeException`.
+ */
+export declare function isFastifyMultipartTooLargeError(error: unknown): boolean;
+export {};
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"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"}

package/dist/adapter.js

@@ -0,0 +1,610 @@
+import multipart from '@fastify/multipart';
+import fastify from 'fastify';
+import fastifyRawBody from 'fastify-raw-body';
+import { createServerBackedHttpAdapterRealtimeCapability, createErrorResponse, HttpException, InternalServerErrorException, PayloadTooLargeException } from '@fluojs/http';
+import { createNodeShutdownSignalRegistration, defaultNodeShutdownSignals } from '@fluojs/runtime/node';
+import { bootstrapHttpAdapterApplication, runHttpAdapterApplication } from '@fluojs/runtime/internal/http-adapter';
+import { dispatchWithRequestResponseFactory } from '@fluojs/runtime/internal/request-response-factory';
+
+/**
+ * Transport-level knobs for the standalone Fastify HTTP adapter factory.
+ */
+
+/** Node.js shutdown signals supported by `runFastifyApplication(...)`. */
+
+/** CORS shorthand accepted by the Fastify runtime bootstrap helpers. */
+
+const DEFAULT_MAX_BODY_SIZE = 1 * 1024 * 1024;
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 10_000;
+
+/**
+ * Bootstrap options for creating a Fastify-backed application without
+ * implicitly registering process shutdown listeners.
+ */
+
+/**
+ * Bootstrap options for `runFastifyApplication(...)`, including shutdown hooks.
+ */
+
+/**
+ * Fastify-backed `HttpApplicationAdapter` implementation used by the runtime.
+ *
+ * It preserves the shared Fluo dispatcher contract while exposing Fastify's
+ * server-backed realtime capability and multipart/raw-body integrations.
+ */
+export class FastifyHttpApplicationAdapter {
+  closeInFlight;
+  dispatcher;
+  pluginsReady = false;
+  app;
+  requestResponseFactory;
+  constructor(port, host, retryDelayMs = 150, retryLimit = 20, httpsOptions, multipartOptions, maxBodySize = DEFAULT_MAX_BODY_SIZE, preserveRawBody = false, shutdownTimeoutMs = DEFAULT_SHUTDOWN_TIMEOUT_MS) {
+    this.port = port;
+    this.host = host;
+    this.retryDelayMs = retryDelayMs;
+    this.retryLimit = retryLimit;
+    this.httpsOptions = httpsOptions;
+    this.multipartOptions = multipartOptions;
+    this.maxBodySize = maxBodySize;
+    this.preserveRawBody = preserveRawBody;
+    this.shutdownTimeoutMs = shutdownTimeoutMs;
+    this.app = createFastifyApp(this.httpsOptions, this.maxBodySize);
+    this.requestResponseFactory = createFastifyRequestResponseFactory(this.multipartOptions, this.maxBodySize, this.preserveRawBody);
+  }
+  getServer() {
+    return this.app.server;
+  }
+  getRealtimeCapability() {
+    return createServerBackedHttpAdapterRealtimeCapability(this.app.server);
+  }
+  getListenTarget() {
+    return resolveListenTarget(this.app.server.address() ?? null, this.port, this.host, this.httpsOptions !== undefined);
+  }
+  async listen(dispatcher) {
+    this.dispatcher = dispatcher;
+    await this.registerPluginsAndRoute();
+    await this.listenWithRetry();
+  }
+  async close() {
+    if (!this.app.server.listening) {
+      this.dispatcher = undefined;
+      return;
+    }
+    if (!this.closeInFlight) {
+      const closePromise = this.app.close();
+      const closeInFlight = closePromise.finally(() => {
+        this.closeInFlight = undefined;
+        this.dispatcher = undefined;
+      });
+      this.closeInFlight = closeInFlight;
+      void closeInFlight.catch(() => {});
+    }
+    const closeInFlight = this.closeInFlight;
+    if (!closeInFlight) {
+      return;
+    }
+    await waitForCloseWithTimeout(closeInFlight, this.shutdownTimeoutMs);
+  }
+  async registerPluginsAndRoute() {
+    if (this.pluginsReady) {
+      return;
+    }
+    await this.app.register(multipart);
+    if (this.preserveRawBody) {
+      await this.app.register(fastifyRawBody, {
+        encoding: 'utf8',
+        field: 'rawBody',
+        global: true,
+        runFirst: true
+      });
+    }
+    this.app.all('*', async (request, reply) => {
+      await this.handleRequest(request, reply);
+    });
+    this.pluginsReady = true;
+  }
+  async listenWithRetry() {
+    for (let attempt = 0;; attempt++) {
+      try {
+        await this.app.listen({
+          host: this.host,
+          port: this.port
+        });
+        return;
+      } catch (error) {
+        if (!isAddressInUseError(error) || attempt >= this.retryLimit) {
+          throw error;
+        }
+        await delay(this.retryDelayMs);
+      }
+    }
+  }
+  async handleRequest(request, reply) {
+    await dispatchWithRequestResponseFactory({
+      dispatcher: this.dispatcher,
+      dispatcherNotReadyMessage: 'Fastify adapter received a request before dispatcher binding completed.',
+      factory: this.requestResponseFactory,
+      rawRequest: request,
+      rawResponse: reply
+    });
+  }
+}
+function createFastifyRequestResponseFactory(multipartOptions, maxBodySize = DEFAULT_MAX_BODY_SIZE, preserveRawBody = false) {
+  return {
+    async createRequest(request, signal) {
+      return createFrameworkRequest(request, signal, multipartOptions, maxBodySize, preserveRawBody);
+    },
+    createRequestSignal(reply) {
+      return createRequestSignal(reply.raw);
+    },
+    createResponse(reply) {
+      return createFrameworkResponse(reply);
+    },
+    resolveRequestId(request) {
+      return resolveRequestIdFromHeaders(request.raw.headers);
+    },
+    async writeErrorResponse(error, response, requestId) {
+      const httpError = toHttpException(error);
+      response.setStatus(httpError.status);
+      await response.send(createErrorResponse(httpError, requestId));
+    }
+  };
+}
+
+/**
+ * Create the recommended Fastify adapter for `FluoFactory.create(...)`.
+ *
+ * @example
+ * ```ts
+ * const app = await FluoFactory.create(AppModule, {
+ *   adapter: createFastifyAdapter({ port: 3000 }),
+ * });
+ * ```
+ *
+ * @param options Transport-level Fastify settings such as host, port, retries, and raw-body preservation.
+ * @param multipartOptions Optional multipart parsing limits exposed through `FrameworkRequest.files`.
+ * @returns A runtime `HttpApplicationAdapter` backed by Fastify.
+ */
+export function createFastifyAdapter(options = {}, multipartOptions) {
+  return new FastifyHttpApplicationAdapter(resolvePort(options.port), options.host, options.retryDelayMs, options.retryLimit, options.https, multipartOptions, options.maxBodySize, options.rawBody, options.shutdownTimeoutMs);
+}
+
+/**
+ * Bootstrap a Fastify-backed application without implicitly calling `listen()`.
+ *
+ * @param rootModule Root application module compiled by the Fluo runtime.
+ * @param options Runtime, middleware, and Fastify adapter settings.
+ * @returns An initialized application shell that can be listened to later.
+ */
+export async function bootstrapFastifyApplication(rootModule, options) {
+  return bootstrapHttpAdapterApplication(rootModule, options, createFastifyAdapter(options, options.multipart));
+}
+
+/**
+ * Bootstrap and prepare a Fastify-backed application with shutdown registration.
+ *
+ * This helper mirrors the README quick-start path: create the adapter, wire the
+ * runtime, and attach signal handling so callers only need to invoke `listen()`.
+ *
+ * @param rootModule Root application module compiled by the Fluo runtime.
+ * @param options Runtime, adapter, and shutdown registration settings.
+ * @returns A bootstrapped application shell ready to listen.
+ */
+export async function runFastifyApplication(rootModule, options) {
+  const adapter = createFastifyAdapter(options, options.multipart);
+  return runHttpAdapterApplication(rootModule, {
+    ...options,
+    shutdownRegistration: createNodeShutdownSignalRegistration(options.shutdownSignals ?? defaultNodeShutdownSignals())
+  }, adapter);
+}
+function createFrameworkResponse(reply) {
+  return {
+    committed: reply.sent,
+    headers: {},
+    raw: reply,
+    stream: createFrameworkResponseStream(reply),
+    redirect(status, location) {
+      this.setStatus(status);
+      this.setHeader('Location', location);
+      this.committed = true;
+      reply.redirect(location, status);
+    },
+    async send(body) {
+      if (reply.sent) {
+        this.committed = true;
+        return;
+      }
+      const existingContentType = reply.getHeader('content-type');
+      const serialized = serializeResponseBody(body, typeof existingContentType === 'string' ? existingContentType : undefined);
+      if (!reply.hasHeader('content-type') && serialized.defaultContentType) {
+        reply.header('content-type', serialized.defaultContentType);
+      }
+      this.committed = true;
+      await reply.send(serialized.payload);
+    },
+    setHeader(name, value) {
+      const lowerName = name.toLowerCase();
+      if (lowerName === 'set-cookie') {
+        const merged = mergeSetCookieHeader(reply.getHeader(name), value);
+        reply.header(name, merged);
+        this.headers[name] = merged;
+        return;
+      }
+      reply.header(name, value);
+      this.headers[name] = value;
+    },
+    setStatus(code) {
+      reply.status(code);
+      this.statusCode = code;
+      this.statusSet = true;
+    },
+    statusCode: undefined,
+    statusSet: false
+  };
+}
+function createFrameworkResponseStream(reply) {
+  let hijacked = false;
+  const ensureHijacked = () => {
+    if (!hijacked && !reply.sent) {
+      reply.raw.statusCode = reply.statusCode;
+      for (const [name, value] of Object.entries(reply.getHeaders())) {
+        if (value !== undefined) {
+          reply.raw.setHeader(name, value);
+        }
+      }
+      reply.hijack();
+      hijacked = true;
+    }
+  };
+  return {
+    close() {
+      ensureHijacked();
+      if (!reply.raw.writableEnded) {
+        reply.raw.end();
+      }
+    },
+    get closed() {
+      return reply.raw.writableEnded;
+    },
+    flush() {
+      ensureHijacked();
+      reply.raw.flushHeaders?.();
+    },
+    onClose(listener) {
+      reply.raw.on('close', listener);
+      return () => {
+        reply.raw.removeListener('close', listener);
+      };
+    },
+    waitForDrain() {
+      ensureHijacked();
+      if (reply.raw.writableEnded) {
+        return Promise.resolve();
+      }
+      return new Promise(resolve => {
+        reply.raw.once('drain', () => resolve());
+      });
+    },
+    write(chunk) {
+      ensureHijacked();
+      return reply.raw.write(chunk);
+    }
+  };
+}
+async function createFrameworkRequest(request, signal, multipartOptions, maxBodySize = DEFAULT_MAX_BODY_SIZE, preserveRawBody = false) {
+  const rawUrl = request.raw.url ?? '/';
+  const url = new URL(rawUrl, 'http://localhost');
+  const headers = normalizeHeaders(request.headers);
+  const contentType = headers['content-type'];
+  const isMultipart = typeof contentType === 'string' && contentType.includes('multipart/form-data');
+  let body = request.body;
+  let files;
+  if (isMultipart) {
+    const parsed = await parseMultipartRequest(request, {
+      ...multipartOptions,
+      maxTotalSize: multipartOptions?.maxTotalSize ?? maxBodySize
+    });
+    body = parsed.fields;
+    files = parsed.files;
+  }
+  const frameworkRequest = {
+    body,
+    cookies: parseCookieHeader(Array.isArray(headers.cookie) ? headers.cookie[0] : headers.cookie),
+    headers,
+    method: request.method,
+    params: {},
+    path: url.pathname,
+    query: parseQueryParams(url.searchParams),
+    raw: request.raw,
+    signal,
+    url: url.pathname + url.search
+  };
+  if (files) {
+    frameworkRequest.files = files;
+  }
+  if (preserveRawBody && !isMultipart) {
+    const rawBodyValue = request.rawBody;
+    if (rawBodyValue !== undefined) {
+      frameworkRequest.rawBody = typeof rawBodyValue === 'string' ? Buffer.from(rawBodyValue, 'utf8') : rawBodyValue;
+    }
+  }
+  return frameworkRequest;
+}
+async function parseMultipartRequest(request, options = {}) {
+  const fields = {};
+  const files = [];
+  const maxFileSize = options.maxFileSize ?? 10 * 1024 * 1024;
+  const maxFiles = options.maxFiles ?? 10;
+  const maxTotalSize = options.maxTotalSize ?? 10 * 1024 * 1024;
+  const contentLength = Number(request.headers['content-length']);
+  let totalSize = 0;
+  if (Number.isFinite(contentLength) && contentLength > maxTotalSize) {
+    throw new PayloadTooLargeException('Request body exceeds the configured multipart limits.');
+  }
+  try {
+    for await (const part of request.parts({
+      limits: {
+        fileSize: maxFileSize,
+        files: maxFiles
+      }
+    })) {
+      if (part.type === 'file') {
+        if (files.length >= maxFiles) {
+          throw new PayloadTooLargeException(`Exceeded maximum file count of ${String(maxFiles)}.`);
+        }
+        const buffer = await part.toBuffer();
+        totalSize += buffer.byteLength;
+        if (totalSize > maxTotalSize) {
+          throw new PayloadTooLargeException('Request body exceeds the configured multipart limits.');
+        }
+        files.push({
+          buffer,
+          fieldname: part.fieldname,
+          mimetype: part.mimetype,
+          originalname: part.filename,
+          size: buffer.byteLength
+        });
+        continue;
+      }
+      const value = String(part.value ?? '');
+      totalSize += Buffer.byteLength(value, 'utf8');
+      if (totalSize > maxTotalSize) {
+        throw new PayloadTooLargeException('Request body exceeds the configured multipart limits.');
+      }
+      setMultiValue(fields, part.fieldname, value);
+    }
+  } catch (error) {
+    if (isFastifyMultipartTooLargeError(error)) {
+      throw new PayloadTooLargeException('Request body exceeds the configured multipart limits.');
+    }
+    throw error;
+  }
+  return {
+    fields,
+    files
+  };
+}
+
+/**
+ * Detect whether a thrown Fastify multipart error maps to payload-too-large semantics.
+ *
+ * @param error Unknown Fastify or plugin error thrown while parsing multipart input.
+ * @returns `true` when the error should surface as `PayloadTooLargeException`.
+ */
+export function isFastifyMultipartTooLargeError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const candidate = error;
+  if (candidate.statusCode === 413) {
+    return true;
+  }
+  if (typeof candidate.code === 'string' && /FILE_TOO_LARGE|LIMIT/i.test(candidate.code)) {
+    return true;
+  }
+  return error.message.includes('toobig') || error.message.includes('File too large');
+}
+function normalizeHeaders(headers) {
+  const normalized = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      normalized[name] = value;
+      continue;
+    }
+    if (typeof value === 'number') {
+      normalized[name] = String(value);
+      continue;
+    }
+    if (typeof value === 'string' || value === undefined) {
+      normalized[name] = value;
+      continue;
+    }
+    normalized[name] = String(value);
+  }
+  return normalized;
+}
+function parseQueryParams(searchParams) {
+  const query = {};
+  for (const [key, value] of searchParams.entries()) {
+    const current = query[key];
+    if (current === undefined) {
+      query[key] = value;
+      continue;
+    }
+    if (Array.isArray(current)) {
+      current.push(value);
+      continue;
+    }
+    query[key] = [current, value];
+  }
+  return query;
+}
+function parseCookieHeader(cookieHeader) {
+  if (!cookieHeader) {
+    return {};
+  }
+  return Object.fromEntries(cookieHeader.split(';').map(pair => pair.trim()).filter(Boolean).map(pair => {
+    const index = pair.indexOf('=');
+    if (index === -1) {
+      return [pair.trim(), ''];
+    }
+    const rawValue = pair.slice(index + 1).trim();
+    try {
+      return [pair.slice(0, index).trim(), decodeURIComponent(rawValue)];
+    } catch {
+      return [pair.slice(0, index).trim(), rawValue];
+    }
+  }));
+}
+function setMultiValue(target, key, value) {
+  const existing = target[key];
+  if (existing === undefined) {
+    target[key] = value;
+    return;
+  }
+  if (Array.isArray(existing)) {
+    existing.push(value);
+    return;
+  }
+  target[key] = [existing, value];
+}
+function createRequestSignal(response) {
+  const controller = new AbortController();
+  const abort = reason => {
+    if (!controller.signal.aborted) {
+      controller.abort(new Error(reason));
+    }
+  };
+  response.once('close', () => {
+    if (!response.writableEnded) {
+      abort('Response closed before response commit.');
+    }
+  });
+  return controller.signal;
+}
+function resolveRequestIdFromHeaders(headers) {
+  const requestId = headers['x-request-id'] ?? headers['x-correlation-id'];
+  return Array.isArray(requestId) ? requestId[0] : requestId;
+}
+function createFastifyApp(httpsOptions, maxBodySize) {
+  if (httpsOptions) {
+    return fastify({
+      bodyLimit: maxBodySize,
+      https: httpsOptions,
+      logger: false
+    });
+  }
+  return fastify({
+    bodyLimit: maxBodySize,
+    logger: false
+  });
+}
+function resolveListenTarget(address, port, host, useHttps) {
+  const protocol = useHttps ? 'https' : 'http';
+  const resolvedPort = typeof address === 'object' && address !== null ? address.port : port;
+  const bindHost = typeof address === 'object' && address !== null ? address.address : host ?? '0.0.0.0';
+  const publicHost = resolvePublicHost(host ?? bindHost);
+  const bindTarget = `${formatHostForAuthority(bindHost)}:${String(resolvedPort)}`;
+  const url = `${protocol}://${formatHostForAuthority(publicHost)}:${String(resolvedPort)}`;
+  return {
+    bindTarget,
+    url
+  };
+}
+function resolvePublicHost(host) {
+  return isWildcardHost(host) ? 'localhost' : host;
+}
+function isWildcardHost(host) {
+  return host === '0.0.0.0' || host === '::' || host === '[::]';
+}
+function formatHostForAuthority(host) {
+  return host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+}
+function resolvePort(value) {
+  const port = value ?? 3000;
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error(`Invalid PORT value: ${String(value ?? 3000)}.`);
+  }
+  return port;
+}
+function toHttpException(error) {
+  if (error instanceof HttpException) {
+    return error;
+  }
+  return new InternalServerErrorException('Internal server error.', {
+    cause: error
+  });
+}
+function isAddressInUseError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.code === 'EADDRINUSE';
+}
+function delay(ms) {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+}
+function waitForCloseWithTimeout(closePromise, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`Fastify adapter shutdown timeout exceeded ${String(timeoutMs)}ms.`));
+    }, timeoutMs);
+    void closePromise.then(() => {
+      clearTimeout(timeout);
+      resolve();
+    }, error => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+  });
+}
+function mergeSetCookieHeader(current, incoming) {
+  const nextValues = Array.isArray(incoming) ? incoming : [incoming];
+  if (current === undefined || typeof current === 'number') {
+    return nextValues.length === 1 ? nextValues[0] : [...nextValues];
+  }
+  const currentValues = Array.isArray(current) ? current : [current];
+  const merged = [...currentValues, ...nextValues];
+  return merged.length === 1 ? merged[0] : merged;
+}
+function serializeResponseBody(body, contentType) {
+  if (body === undefined) {
+    return {
+      payload: ''
+    };
+  }
+  if (Buffer.isBuffer(body)) {
+    return {
+      defaultContentType: 'application/octet-stream',
+      payload: body
+    };
+  }
+  if (body instanceof Uint8Array) {
+    return {
+      defaultContentType: 'application/octet-stream',
+      payload: Buffer.from(body)
+    };
+  }
+  if (body instanceof ArrayBuffer) {
+    return {
+      defaultContentType: 'application/octet-stream',
+      payload: Buffer.from(body)
+    };
+  }
+  if (typeof body === 'string') {
+    const isJson = isJsonContentType(contentType);
+    return {
+      defaultContentType: isJson ? undefined : 'text/plain; charset=utf-8',
+      payload: isJson ? JSON.stringify(body) : body
+    };
+  }
+  return {
+    defaultContentType: 'application/json; charset=utf-8',
+    payload: JSON.stringify(body)
+  };
+}
+function isJsonContentType(contentType) {
+  return typeof contentType === 'string' && contentType.toLowerCase().includes('application/json');
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export * from './adapter.js';

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@fluojs/platform-fastify",
+  "description": "Fastify-based HTTP adapter for the Fluo runtime.",
+  "keywords": [
+    "fluo",
+    "fastify",
+    "http-adapter",
+    "platform",
+    "server"
+  ],
+  "version": "1.0.0-beta.1",
+  "private": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fluojs/fluo.git",
+    "directory": "packages/platform-fastify"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@fastify/multipart": "^9.2.1",
+    "fastify": "^5.6.1",
+    "fastify-raw-body": "^5.0.0",
+    "@fluojs/http": "^1.0.0-beta.1",
+    "@fluojs/runtime": "^1.0.0-beta.1"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "prebuild": "node ../../tooling/scripts/clean-dist.mjs",
+    "build": "pnpm exec babel src --extensions .ts --ignore 'src/**/*.test.ts' --out-dir dist --config-file ../../tooling/babel/babel.config.cjs && pnpm exec tsc -p tsconfig.build.json",
+    "typecheck": "pnpm exec tsc -p tsconfig.json --noEmit",
+    "test": "pnpm exec vitest run -c vitest.config.ts",
+    "test:watch": "pnpm exec vitest -c vitest.config.ts"
+  }
+}