@fluojs/platform-nodejs 1.0.6 → 2.0.0

package/dist/node/internal-node-response.js

@@ -0,0 +1,181 @@
+import { createErrorResponse, HttpException, InternalServerErrorException } from '@fluojs/http';
+import { createNodeEarlyHintsCapability } from './internal-node-early-hints.js';
+import { createFrameworkResponseStream } from './internal-node-response-stream.js';
+
+/**
+ * Defines the mutable framework response type.
+ */
+
+/**
+ * Create framework response.
+ *
+ * @param response The response.
+ * @param compression The compression.
+ * @returns The create framework response result.
+ */
+export function createFrameworkResponse(response, compression) {
+  let activeStream;
+  const resolveCompression = (() => {
+    const factory = typeof compression === 'function' ? compression : () => compression;
+    let resolved = false;
+    let value;
+    return () => {
+      if (!resolved) {
+        value = factory();
+        resolved = true;
+      }
+      return value;
+    };
+  })();
+  const mergeSetCookieHeader = (current, incoming) => {
+    const nextValues = Array.isArray(incoming) ? incoming : [incoming];
+    if (current === undefined) {
+      return nextValues.length === 1 ? nextValues[0] : [...nextValues];
+    }
+    if (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;
+  };
+  let frameworkResponse;
+  frameworkResponse = {
+    committed: response.headersSent || response.writableEnded,
+    earlyHints: createNodeEarlyHintsCapability(response, () => frameworkResponse.committed),
+    headers: {},
+    raw: response,
+    get stream() {
+      activeStream ??= createFrameworkResponseStream(response);
+      return activeStream;
+    },
+    redirect(status, location) {
+      this.setStatus(status);
+      this.setHeader('Location', location);
+      void this.send(undefined);
+    },
+    send(body, options) {
+      if (response.writableEnded) {
+        this.committed = true;
+        return;
+      }
+      const hasContentType = response.hasHeader('Content-Type');
+      const existingContentType = response.getHeader('Content-Type');
+      const serialized = serializeResponseBody(body, typeof existingContentType === 'string' ? existingContentType : undefined);
+      const adapterDefaultContentType = hasContentType ? undefined : serialized.defaultContentType;
+      if (adapterDefaultContentType) {
+        response.setHeader('Content-Type', adapterDefaultContentType);
+      }
+      const contentType = response.getHeader('Content-Type');
+      const payload = typeof serialized.payload === 'string' ? Buffer.from(serialized.payload, 'utf8') : serialized.payload;
+      if (options?.compression !== false && response.statusCode !== 206 && !response.hasHeader('Content-Range')) {
+        const activeCompression = resolveCompression();
+        if (activeCompression) {
+          this.committed = true;
+          return Promise.resolve().then(() => activeCompression.write(payload, {
+            contentType
+          })).then(handled => {
+            if (!handled && !response.writableEnded) {
+              response.end(payload);
+            }
+          }).catch(error => {
+            if (response.headersSent || response.writableEnded || response.destroyed) {
+              if (!response.writableEnded && !response.destroyed) {
+                response.destroy();
+              }
+            } else {
+              response.removeHeader('Content-Encoding');
+              if (adapterDefaultContentType) {
+                response.removeHeader('Content-Type');
+              }
+              this.committed = false;
+            }
+            throw error;
+          });
+        }
+      }
+      response.end(payload);
+      this.committed = true;
+    },
+    setHeader(name, value) {
+      const headers = this.headers;
+      const lowerName = name.toLowerCase();
+      if (lowerName === 'set-cookie') {
+        const merged = mergeSetCookieHeader(response.getHeader(name), value);
+        response.setHeader(name, merged);
+        headers[name] = merged;
+        return;
+      }
+      response.setHeader(name, value);
+      headers[name] = value;
+    },
+    setStatus(code) {
+      response.statusCode = code;
+      this.statusCode = code;
+      this.statusSet = true;
+    },
+    statusCode: undefined,
+    statusSet: false
+  };
+  return frameworkResponse;
+}
+
+/**
+ * Write node adapter error response.
+ *
+ * @param error The error.
+ * @param response The response.
+ * @param requestId The request id.
+ * @returns The write node adapter error response result.
+ */
+export async function writeNodeAdapterErrorResponse(error, response, requestId) {
+  const httpError = toHttpException(error);
+  response.setStatus(httpError.status);
+  await response.send(createErrorResponse(httpError, requestId));
+}
+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') {
+    return {
+      defaultContentType: isJsonContentType(contentType) ? undefined : 'text/plain; charset=utf-8',
+      payload: isJsonContentType(contentType) ? 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');
+}
+function toHttpException(error) {
+  if (error instanceof HttpException) {
+    return error;
+  }
+  return new InternalServerErrorException('Internal server error.', {
+    cause: error
+  });
+}

package/dist/node/internal-node-shutdown.d.ts

@@ -0,0 +1,34 @@
+import type { Application, ApplicationLogger } from '@fluojs/runtime';
+import type { HttpAdapterShutdownRegistration } from '@fluojs/runtime/internal/http-adapter';
+type NodeShutdownSignal = 'SIGINT' | 'SIGTERM';
+/**
+ * Returns the default POSIX shutdown signals used by Node-hosted runtime helpers.
+ *
+ * @returns The ordered list of signals that trigger graceful shutdown registration.
+ */
+export declare function defaultNodeShutdownSignals(): readonly NodeShutdownSignal[];
+/**
+ * Creates shutdown registration logic for Node-hosted adapters.
+ *
+ * The returned registration preserves graceful shutdown semantics while leaving
+ * final process termination ownership to the surrounding host/runtime.
+ *
+ * @param signals Signals to register, or `false` to disable signal handling.
+ * @returns Registration callback consumed by HTTP adapter startup helpers.
+ */
+export declare function createNodeShutdownSignalRegistration(signals?: false | readonly NodeShutdownSignal[]): HttpAdapterShutdownRegistration;
+/**
+ * Registers process signal handlers that attempt graceful shutdown.
+ *
+ * When the shutdown timeout elapses, the helper records failure via logging and
+ * `process.exitCode` but does not terminate the host process directly.
+ *
+ * @param app Application instance to close when a signal arrives.
+ * @param logger Logger used for shutdown diagnostics.
+ * @param signals Signals to bind, or `false` to skip registration.
+ * @param forceExitTimeoutMs Timeout window used to mark shutdown as failed.
+ * @returns Unregister callback that removes the installed signal handlers.
+ */
+export declare function registerShutdownSignals(app: Application, logger: ApplicationLogger, signals: false | readonly NodeShutdownSignal[], forceExitTimeoutMs?: number): () => void;
+export {};
+//# sourceMappingURL=internal-node-shutdown.d.ts.map

package/dist/node/internal-node-shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-node-shutdown.d.ts","sourceRoot":"","sources":["../../src/node/internal-node-shutdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,uCAAuC,CAAC;AAE7F,KAAK,kBAAkB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAI/C;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,SAAS,kBAAkB,EAAE,CAE1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,oCAAoC,CAClD,OAAO,GAAE,KAAK,GAAG,SAAS,kBAAkB,EAAiC,GAC5E,+BAA+B,CAOjC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,KAAK,GAAG,SAAS,kBAAkB,EAAE,EAC9C,kBAAkB,GAAE,MAAsC,GACzD,MAAM,IAAI,CAqBZ"}

package/dist/node/internal-node-shutdown.js

@@ -0,0 +1,83 @@
+const DEFAULT_FORCE_EXIT_TIMEOUT_MS = 30_000;
+
+/**
+ * Returns the default POSIX shutdown signals used by Node-hosted runtime helpers.
+ *
+ * @returns The ordered list of signals that trigger graceful shutdown registration.
+ */
+export function defaultNodeShutdownSignals() {
+  return ['SIGINT', 'SIGTERM'];
+}
+
+/**
+ * Creates shutdown registration logic for Node-hosted adapters.
+ *
+ * The returned registration preserves graceful shutdown semantics while leaving
+ * final process termination ownership to the surrounding host/runtime.
+ *
+ * @param signals Signals to register, or `false` to disable signal handling.
+ * @returns Registration callback consumed by HTTP adapter startup helpers.
+ */
+export function createNodeShutdownSignalRegistration(signals = defaultNodeShutdownSignals()) {
+  return (app, logger, forceExitTimeoutMs) => registerShutdownSignals(app, logger, signals, forceExitTimeoutMs);
+}
+
+/**
+ * Registers process signal handlers that attempt graceful shutdown.
+ *
+ * When the shutdown timeout elapses, the helper records failure via logging and
+ * `process.exitCode` but does not terminate the host process directly.
+ *
+ * @param app Application instance to close when a signal arrives.
+ * @param logger Logger used for shutdown diagnostics.
+ * @param signals Signals to bind, or `false` to skip registration.
+ * @param forceExitTimeoutMs Timeout window used to mark shutdown as failed.
+ * @returns Unregister callback that removes the installed signal handlers.
+ */
+export function registerShutdownSignals(app, logger, signals, forceExitTimeoutMs = DEFAULT_FORCE_EXIT_TIMEOUT_MS) {
+  if (signals === false) {
+    return () => {};
+  }
+  const bindings = [];
+  for (const signal of signals) {
+    const handler = () => {
+      void closeFromSignal(app, logger, signal, forceExitTimeoutMs);
+    };
+    bindings.push({
+      signal,
+      handler
+    });
+    process.once(signal, handler);
+  }
+  return () => {
+    for (const binding of bindings) {
+      process.off(binding.signal, binding.handler);
+    }
+  };
+}
+async function closeFromSignal(app, logger, signal, forceExitTimeoutMs) {
+  if (app.state === 'closed') {
+    process.exitCode = 0;
+    return;
+  }
+  let timedOut = false;
+  const forceExitTimer = setTimeout(() => {
+    timedOut = true;
+    logger.error(`Shutdown timeout exceeded after ${String(forceExitTimeoutMs)}ms; leaving process termination to the host.`, undefined, 'FluoFactory');
+    process.exitCode = 1;
+  }, forceExitTimeoutMs);
+  if (forceExitTimer.unref) {
+    forceExitTimer.unref();
+  }
+  try {
+    await app.close(signal);
+    clearTimeout(forceExitTimer);
+    if (!timedOut) {
+      process.exitCode = 0;
+    }
+  } catch (error) {
+    clearTimeout(forceExitTimer);
+    logger.error('Failed to shut down the application cleanly.', error, 'FluoFactory');
+    process.exitCode = 1;
+  }
+}

package/dist/node/internal-node.d.ts

@@ -0,0 +1,114 @@
+import { createServer as createHttpServer, type ServerOptions as HttpServerOptions } from 'node:http';
+import { createServer as createHttpsServer, type ServerOptions as HttpsServerOptions } from 'node:https';
+import { type CorsOptions, type Dispatcher, type HttpApplicationAdapter, type MiddlewareLike, type SecurityHeadersOptions } from '@fluojs/http';
+import type { Application, ApplicationLogger, CreateApplicationOptions, ModuleType, MultipartOptions } from '@fluojs/runtime';
+import { compressNodeResponse, createNodeResponseCompression } from './internal-node-compression.js';
+import { cloneHeaderValue, cloneRequestHeaders, createDeferredFrameworkRequestShell, createMemoizedAsyncValue, createMemoizedValue, createRequestSignal, normalizePrimaryContentType, parseCookieHeader, parseQueryParamsFromSearch, readPrimaryHeaderValue, resolveAbsoluteRequestUrl, resolveRequestIdFromHeaders, snapshotSimpleQueryRecord, splitRawRequestUrl } from './internal-node-request.js';
+import { createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals } from './internal-node-shutdown.js';
+/**
+ * Describes the node http adapter options contract.
+ */
+export interface NodeHttpAdapterOptions {
+    host?: string;
+    http?: HttpServerOptions;
+    https?: HttpsServerOptions;
+    maxBodySize?: number;
+    port?: number;
+    rawBody?: boolean;
+    retryDelayMs?: number;
+    retryLimit?: number;
+    shutdownTimeoutMs?: number;
+}
+/**
+ * Defines the node application signal type.
+ */
+export type NodeApplicationSignal = 'SIGINT' | 'SIGTERM';
+/**
+ * Defines the cors input type.
+ */
+export type CorsInput = false | string | string[] | CorsOptions;
+/**
+ * Describes the bootstrap node application options contract.
+ */
+export interface BootstrapNodeApplicationOptions extends Omit<CreateApplicationOptions, 'adapter' | 'logger' | 'middleware'> {
+    compression?: boolean;
+    cors?: CorsInput;
+    globalPrefix?: string;
+    globalPrefixExclude?: readonly string[];
+    host?: string;
+    http?: HttpServerOptions;
+    https?: HttpsServerOptions;
+    logger?: ApplicationLogger;
+    maxBodySize?: number;
+    middleware?: MiddlewareLike[];
+    multipart?: MultipartOptions;
+    port?: number;
+    rawBody?: boolean;
+    retryDelayMs?: number;
+    retryLimit?: number;
+    securityHeaders?: false | SecurityHeadersOptions;
+    shutdownTimeoutMs?: number;
+}
+/**
+ * Describes the run node application options contract.
+ */
+export interface RunNodeApplicationOptions extends BootstrapNodeApplicationOptions {
+    forceExitTimeoutMs?: number;
+    shutdownSignals?: false | readonly NodeApplicationSignal[];
+}
+interface NodeListenTarget {
+    bindTarget: string;
+    url: string;
+}
+type NodeServer = ReturnType<typeof createHttpServer> | ReturnType<typeof createHttpsServer>;
+/**
+ * Represents the node http application adapter.
+ */
+export declare class NodeHttpApplicationAdapter implements HttpApplicationAdapter {
+    private readonly port;
+    private readonly host;
+    private readonly retryDelayMs;
+    private readonly retryLimit;
+    private readonly httpsOptions;
+    private readonly shutdownTimeoutMs;
+    private readonly httpOptions?;
+    private readonly server;
+    private readonly listenLifecycle;
+    private dispatcher?;
+    private readonly requestResponseFactory;
+    private readonly sockets;
+    constructor(port: number, host: string | undefined, retryDelayMs: number | undefined, retryLimit: number | undefined, compression: boolean | undefined, httpsOptions: HttpsServerOptions | undefined, multipartOptions?: MultipartOptions, maxBodySize?: number, preserveRawBody?: boolean, shutdownTimeoutMs?: number, httpOptions?: HttpServerOptions | undefined);
+    getServer(): NodeServer;
+    getRealtimeCapability(): import("@fluojs/http").ServerBackedHttpAdapterRealtimeCapability;
+    getListenTarget(): NodeListenTarget;
+    listen(dispatcher: Dispatcher): Promise<void>;
+    close(): Promise<void>;
+    private handleRequest;
+}
+/**
+ * Create node http adapter.
+ *
+ * @param options The options.
+ * @param compression The compression.
+ * @param multipartOptions The multipart options.
+ * @returns The create node http adapter result.
+ */
+export declare function createNodeHttpAdapter(options?: NodeHttpAdapterOptions, compression?: boolean, multipartOptions?: MultipartOptions): HttpApplicationAdapter;
+/**
+ * Bootstrap node application.
+ *
+ * @param rootModule The root module.
+ * @param options The options.
+ * @returns The bootstrap node application result.
+ */
+export declare function bootstrapNodeApplication(rootModule: ModuleType, options: BootstrapNodeApplicationOptions): Promise<Application>;
+/**
+ * Run node application.
+ *
+ * @param rootModule The root module.
+ * @param options The options.
+ * @returns The run node application result.
+ */
+export declare function runNodeApplication(rootModule: ModuleType, options: RunNodeApplicationOptions): Promise<Application>;
+export { cloneHeaderValue, cloneRequestHeaders, compressNodeResponse, createDeferredFrameworkRequestShell, createMemoizedAsyncValue, createMemoizedValue, createNodeResponseCompression, createNodeShutdownSignalRegistration, createRequestSignal, defaultNodeShutdownSignals, normalizePrimaryContentType, parseCookieHeader, parseQueryParamsFromSearch, readPrimaryHeaderValue, registerShutdownSignals, resolveAbsoluteRequestUrl, resolveRequestIdFromHeaders, snapshotSimpleQueryRecord, splitRawRequestUrl, };
+//# sourceMappingURL=internal-node.d.ts.map

package/dist/node/internal-node.d.ts.map

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

package/dist/node/internal-node.js

@@ -0,0 +1,262 @@
+import { createServer as createHttpServer } from 'node:http';
+import { createServer as createHttpsServer } from 'node:https';
+import { createServerBackedHttpAdapterRealtimeCapability } from '@fluojs/http';
+import { bootstrapHttpAdapterApplication, runHttpAdapterApplication } from '@fluojs/runtime/internal/http-adapter';
+import { dispatchWithRequestResponseFactory } from '@fluojs/runtime/internal/request-response-factory';
+import { compressNodeResponse, createNodeResponseCompression } from './internal-node-compression.js';
+import { NodeListenLifecycle } from './internal-node-listen.js';
+import { cloneHeaderValue, cloneRequestHeaders, createDeferredFrameworkRequest, createDeferredFrameworkRequestShell, createMemoizedAsyncValue, createMemoizedValue, createRequestSignal, materializeFrameworkRequestBody, NodeRequestPayloadTooLargeException, normalizePrimaryContentType, parseCookieHeader, parseQueryParamsFromSearch, readPrimaryHeaderValue, resolveAbsoluteRequestUrl, resolveRequestIdFromHeaders, snapshotSimpleQueryRecord, splitRawRequestUrl } from './internal-node-request.js';
+import { createFrameworkResponse, writeNodeAdapterErrorResponse } from './internal-node-response.js';
+import { createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals } from './internal-node-shutdown.js';
+import { createConsoleApplicationLogger } from './logger.js';
+
+/**
+ * Describes the node http adapter options contract.
+ */
+
+/**
+ * Defines the node application signal type.
+ */
+
+/**
+ * Defines the cors input type.
+ */
+
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 10_000;
+
+/**
+ * Describes the bootstrap node application options contract.
+ */
+
+/**
+ * Describes the run node application options contract.
+ */
+
+/**
+ * Represents the node http application adapter.
+ */
+export class NodeHttpApplicationAdapter {
+  server;
+  listenLifecycle;
+  dispatcher;
+  requestResponseFactory;
+  sockets = new Set();
+  constructor(port, host, retryDelayMs = 150, retryLimit = 20, compression = false, httpsOptions, multipartOptions, maxBodySize = 1 * 1024 * 1024, preserveRawBody = false, shutdownTimeoutMs = DEFAULT_SHUTDOWN_TIMEOUT_MS, httpOptions) {
+    this.port = port;
+    this.host = host;
+    this.retryDelayMs = retryDelayMs;
+    this.retryLimit = retryLimit;
+    this.httpsOptions = httpsOptions;
+    this.shutdownTimeoutMs = shutdownTimeoutMs;
+    this.httpOptions = httpOptions;
+    validateNodeLifecycleOptions({
+      retryDelayMs: this.retryDelayMs,
+      retryLimit: this.retryLimit,
+      shutdownTimeoutMs: this.shutdownTimeoutMs
+    });
+    this.requestResponseFactory = createNodeRequestResponseFactory(compression, multipartOptions, maxBodySize, preserveRawBody);
+    this.server = createNodeServer(this.httpOptions, this.httpsOptions, (request, response) => {
+      void this.handleRequest(request, response);
+    });
+    this.listenLifecycle = new NodeListenLifecycle(this.server, {
+      host: this.host,
+      port: this.port,
+      retryDelayMs: this.retryDelayMs,
+      retryLimit: this.retryLimit
+    });
+    this.server.on('connection', socket => {
+      this.sockets.add(socket);
+      socket.once('close', () => {
+        this.sockets.delete(socket);
+      });
+    });
+  }
+  getServer() {
+    return this.server;
+  }
+  getRealtimeCapability() {
+    return createServerBackedHttpAdapterRealtimeCapability(this.server);
+  }
+  getListenTarget() {
+    return resolveNodeListenTarget(this.server.address() ?? null, this.port, this.host, this.httpsOptions !== undefined);
+  }
+  async listen(dispatcher) {
+    await this.listenLifecycle.listen(() => {
+      this.dispatcher = dispatcher;
+    });
+  }
+  async close() {
+    const server = this.server;
+    await this.listenLifecycle.close(async () => {
+      if (server.listening) {
+        await closeNodeServerWithDrain(server, this.sockets, this.shutdownTimeoutMs);
+      }
+    });
+    this.dispatcher = undefined;
+  }
+  async handleRequest(request, response) {
+    await dispatchWithRequestResponseFactory({
+      dispatcher: this.dispatcher,
+      dispatcherNotReadyMessage: 'Node HTTP adapter received a request before dispatcher binding completed.',
+      factory: this.requestResponseFactory,
+      rawRequest: request,
+      rawResponse: response
+    });
+  }
+}
+function createNodeRequestResponseFactory(compression, multipartOptions, maxBodySize, preserveRawBody) {
+  return {
+    async createRequest(request, signal) {
+      return createDeferredFrameworkRequest(request, signal, multipartOptions, maxBodySize, preserveRawBody);
+    },
+    materializeRequest(request) {
+      return materializeFrameworkRequestBody(request);
+    },
+    createRequestSignal(response) {
+      return createRequestSignal(response);
+    },
+    createResponse(response, request) {
+      return createFrameworkResponse(response, compression ? () => createNodeResponseCompression(response, request.headers['accept-encoding']) : undefined);
+    },
+    resolveRequestId(request) {
+      return resolveRequestIdFromHeaders(request.headers);
+    },
+    async writeErrorResponse(error, response, requestId) {
+      if (error instanceof NodeRequestPayloadTooLargeException) {
+        error.prepareResponse(response.raw);
+      }
+      await writeNodeAdapterErrorResponse(error, response, requestId);
+    }
+  };
+}
+
+/**
+ * Create node http adapter.
+ *
+ * @param options The options.
+ * @param compression The compression.
+ * @param multipartOptions The multipart options.
+ * @returns The create node http adapter result.
+ */
+export function createNodeHttpAdapter(options = {}, compression = false, multipartOptions) {
+  return new NodeHttpApplicationAdapter(resolveNodePort(options.port), options.host, options.retryDelayMs, options.retryLimit, compression, options.https, multipartOptions, resolveNodeMaxBodySize(options.maxBodySize), options.rawBody, options.shutdownTimeoutMs, options.http);
+}
+
+/**
+ * Bootstrap node application.
+ *
+ * @param rootModule The root module.
+ * @param options The options.
+ * @returns The bootstrap node application result.
+ */
+export async function bootstrapNodeApplication(rootModule, options) {
+  const logger = options.logger ?? createConsoleApplicationLogger();
+  return bootstrapHttpAdapterApplication(rootModule, options, createNodeHttpAdapter(options, options.compression ?? false, options.multipart), logger);
+}
+
+/**
+ * Run node application.
+ *
+ * @param rootModule The root module.
+ * @param options The options.
+ * @returns The run node application result.
+ */
+export async function runNodeApplication(rootModule, options) {
+  const logger = options.logger ?? createConsoleApplicationLogger();
+  const adapter = createNodeHttpAdapter(options, options.compression ?? false, options.multipart);
+  return runHttpAdapterApplication(rootModule, {
+    ...options,
+    shutdownRegistration: createNodeShutdownSignalRegistration(options.shutdownSignals ?? defaultNodeShutdownSignals())
+  }, adapter, logger);
+}
+export { cloneHeaderValue, cloneRequestHeaders, compressNodeResponse, createDeferredFrameworkRequestShell, createMemoizedAsyncValue, createMemoizedValue, createNodeResponseCompression, createNodeShutdownSignalRegistration, createRequestSignal, defaultNodeShutdownSignals, normalizePrimaryContentType, parseCookieHeader, parseQueryParamsFromSearch, readPrimaryHeaderValue, registerShutdownSignals, resolveAbsoluteRequestUrl, resolveRequestIdFromHeaders, snapshotSimpleQueryRecord, splitRawRequestUrl };
+function createNodeServer(httpOptions, httpsOptions, handler) {
+  if (httpOptions && httpsOptions) {
+    throw new Error('Plain HTTP and HTTPS server options cannot be used together.');
+  }
+  if (httpOptions) {
+    return createHttpServer(httpOptions, handler);
+  }
+  return httpsOptions ? createHttpsServer(httpsOptions, handler) : createHttpServer(handler);
+}
+function closeNodeServerWithDrain(server, sockets, shutdownTimeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      forceCloseConnections(server, sockets);
+    }, shutdownTimeoutMs);
+    const finish = error => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    };
+    server.close(error => {
+      finish(error);
+    });
+    closeIdleConnections(server);
+  });
+}
+function resolveNodeListenTarget(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 closeIdleConnections(server) {
+  server.closeIdleConnections?.();
+}
+function validateNodeLifecycleOptions(options) {
+  validateNonNegativeIntegerOption('retryDelayMs', options.retryDelayMs);
+  validateNonNegativeIntegerOption('retryLimit', options.retryLimit);
+  validateNonNegativeIntegerOption('shutdownTimeoutMs', options.shutdownTimeoutMs);
+}
+function validateNonNegativeIntegerOption(name, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`Invalid ${name} value: ${String(value)}. Expected a non-negative integer.`);
+  }
+}
+function forceCloseConnections(server, sockets) {
+  if (typeof server.closeAllConnections === 'function') {
+    server.closeAllConnections();
+    return;
+  }
+  for (const socket of sockets) {
+    socket.destroy();
+  }
+}
+function resolveNodePort(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 resolveNodeMaxBodySize(value) {
+  const maxBodySize = value ?? 1 * 1024 * 1024;
+  if (!Number.isInteger(maxBodySize) || maxBodySize < 0) {
+    throw new Error(`Invalid maxBodySize value: ${String(value ?? 1 * 1024 * 1024)}. Expected a non-negative integer number of bytes.`);
+  }
+  return maxBodySize;
+}