@fluojs/runtime 1.0.0-beta.1

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

@@ -0,0 +1,166 @@
+import { createErrorResponse, HttpException, InternalServerErrorException } from '@fluojs/http';
+function createFrameworkResponseStream(response) {
+  return {
+    close() {
+      if (!response.writableEnded) {
+        response.end();
+      }
+    },
+    get closed() {
+      return response.writableEnded;
+    },
+    flush() {
+      response.flushHeaders?.();
+    },
+    onClose(listener) {
+      response.on('close', listener);
+      return () => {
+        response.removeListener('close', listener);
+      };
+    },
+    waitForDrain() {
+      if (response.writableEnded || response.destroyed) {
+        return Promise.resolve();
+      }
+      return new Promise(resolve => {
+        const settle = () => {
+          response.removeListener('drain', settle);
+          response.removeListener('close', settle);
+          response.removeListener('error', settle);
+          resolve();
+        };
+        response.once('drain', settle);
+        response.once('close', settle);
+        response.once('error', settle);
+      });
+    },
+    write(chunk) {
+      return response.write(chunk);
+    }
+  };
+}
+export function createFrameworkResponse(response, compression) {
+  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;
+  };
+  const frameworkResponse = {
+    committed: response.headersSent || response.writableEnded,
+    headers: {},
+    raw: response,
+    stream: createFrameworkResponseStream(response),
+    redirect(status, location) {
+      this.setStatus(status);
+      this.setHeader('Location', location);
+      void this.send(undefined);
+    },
+    send(body) {
+      if (response.writableEnded) {
+        this.committed = true;
+        return;
+      }
+      const existingContentType = response.getHeader('Content-Type');
+      const serialized = serializeResponseBody(body, typeof existingContentType === 'string' ? existingContentType : undefined);
+      if (!response.hasHeader('Content-Type') && serialized.defaultContentType) {
+        response.setHeader('Content-Type', serialized.defaultContentType);
+      }
+      const contentType = response.getHeader('Content-Type');
+      const payload = typeof serialized.payload === 'string' ? Buffer.from(serialized.payload, 'utf8') : serialized.payload;
+      if (compression) {
+        this.committed = true;
+        return Promise.resolve(compression.write(payload, {
+          contentType
+        })).then(handled => {
+          if (!handled && !response.writableEnded) {
+            response.end(payload);
+          }
+        }).catch(() => {
+          if (!response.writableEnded) {
+            response.end();
+          }
+        });
+      }
+      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;
+}
+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 '../types.js';
+import type { HttpAdapterShutdownRegistration } from '../http-adapter-shared.js';
+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,aAAa,CAAC;AAClE,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAC;AAEjF,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,80 @@
+import { createServer as createHttpServer } 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 { createNodeResponseCompression, compressNodeResponse } from './internal-node-compression.js';
+import { createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals } from './internal-node-shutdown.js';
+import type { MultipartOptions, UploadedFile } from '../multipart.js';
+import type { Application, ApplicationLogger, CreateApplicationOptions, ModuleType } from '../types.js';
+declare module '@fluojs/http' {
+    interface FrameworkRequest {
+        files?: UploadedFile[];
+        rawBody?: Uint8Array;
+    }
+}
+export interface NodeHttpAdapterOptions {
+    host?: string;
+    https?: HttpsServerOptions;
+    maxBodySize?: number;
+    port?: number;
+    rawBody?: boolean;
+    retryDelayMs?: number;
+    retryLimit?: number;
+    shutdownTimeoutMs?: number;
+}
+export type NodeApplicationSignal = 'SIGINT' | 'SIGTERM';
+export type CorsInput = false | string | string[] | CorsOptions;
+export interface BootstrapNodeApplicationOptions extends Omit<CreateApplicationOptions, 'adapter' | 'logger' | 'middleware'> {
+    compression?: boolean;
+    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;
+}
+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>;
+export declare class NodeHttpApplicationAdapter implements HttpApplicationAdapter {
+    private readonly port;
+    private readonly host;
+    private readonly retryDelayMs;
+    private readonly retryLimit;
+    private readonly compression;
+    private readonly httpsOptions;
+    private readonly multipartOptions?;
+    private readonly maxBodySize;
+    private readonly preserveRawBody;
+    private readonly shutdownTimeoutMs;
+    private readonly server;
+    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 | undefined, maxBodySize?: number, preserveRawBody?: boolean, shutdownTimeoutMs?: number);
+    getServer(): NodeServer;
+    getRealtimeCapability(): import("@fluojs/http").ServerBackedHttpAdapterRealtimeCapability;
+    getListenTarget(): NodeListenTarget;
+    listen(dispatcher: Dispatcher): Promise<void>;
+    close(): Promise<void>;
+    private handleRequest;
+}
+export declare function createNodeHttpAdapter(options?: NodeHttpAdapterOptions, compression?: boolean, multipartOptions?: MultipartOptions): HttpApplicationAdapter;
+export declare function bootstrapNodeApplication(rootModule: ModuleType, options: BootstrapNodeApplicationOptions): Promise<Application>;
+export declare function runNodeApplication(rootModule: ModuleType, options: RunNodeApplicationOptions): Promise<Application>;
+export { compressNodeResponse, createNodeResponseCompression, createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals, };
+//# 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,209 @@
+import { createServer as createHttpServer } from 'node:http';
+import { createServer as createHttpsServer } from 'node:https';
+import { createServerBackedHttpAdapterRealtimeCapability } from '@fluojs/http';
+import { bootstrapHttpAdapterApplication, runHttpAdapterApplication } from '../http-adapter-shared.js';
+import { createNodeResponseCompression, compressNodeResponse } from './internal-node-compression.js';
+import { createFrameworkRequest, NodeRequestPayloadTooLargeException, createRequestSignal, resolveRequestIdFromHeaders } from './internal-node-request.js';
+import { createFrameworkResponse, writeNodeAdapterErrorResponse } from './internal-node-response.js';
+import { createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals } from './internal-node-shutdown.js';
+import { dispatchWithRequestResponseFactory } from '../adapters/request-response-factory.js';
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 10_000;
+export class NodeHttpApplicationAdapter {
+  server;
+  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) {
+    this.port = port;
+    this.host = host;
+    this.retryDelayMs = retryDelayMs;
+    this.retryLimit = retryLimit;
+    this.compression = compression;
+    this.httpsOptions = httpsOptions;
+    this.multipartOptions = multipartOptions;
+    this.maxBodySize = maxBodySize;
+    this.preserveRawBody = preserveRawBody;
+    this.shutdownTimeoutMs = shutdownTimeoutMs;
+    this.requestResponseFactory = createNodeRequestResponseFactory(compression, multipartOptions, maxBodySize, preserveRawBody);
+    this.server = createNodeServer(this.httpsOptions, (request, response) => {
+      void this.handleRequest(request, response);
+    });
+    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) {
+    this.dispatcher = dispatcher;
+    await listenNodeServerWithRetry(this.server, {
+      host: this.host,
+      port: this.port,
+      retryDelayMs: this.retryDelayMs,
+      retryLimit: this.retryLimit
+    });
+  }
+  async close() {
+    const server = this.server;
+    if (!server.listening) {
+      this.dispatcher = undefined;
+      return;
+    }
+    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 createFrameworkRequest(request, signal, multipartOptions, maxBodySize, preserveRawBody);
+    },
+    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);
+    }
+  };
+}
+export function createNodeHttpAdapter(options = {}, compression = false, multipartOptions) {
+  return new NodeHttpApplicationAdapter(resolveNodePort(options.port), options.host, options.retryDelayMs, options.retryLimit, compression, options.https, multipartOptions, options.maxBodySize, options.rawBody, options.shutdownTimeoutMs);
+}
+export async function bootstrapNodeApplication(rootModule, options) {
+  return bootstrapHttpAdapterApplication(rootModule, options, createNodeHttpAdapter(options, options.compression ?? false, options.multipart));
+}
+export async function runNodeApplication(rootModule, options) {
+  const adapter = createNodeHttpAdapter(options, options.compression ?? false, options.multipart);
+  return runHttpAdapterApplication(rootModule, {
+    ...options,
+    shutdownRegistration: createNodeShutdownSignalRegistration(options.shutdownSignals ?? defaultNodeShutdownSignals())
+  }, adapter);
+}
+export { compressNodeResponse, createNodeResponseCompression, createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals };
+function createNodeServer(httpsOptions, handler) {
+  return httpsOptions ? createHttpsServer(httpsOptions, handler) : createHttpServer(handler);
+}
+function listenNodeServerWithRetry(server, options) {
+  return new Promise((resolve, reject) => {
+    const tryListen = attempt => {
+      const onError = error => {
+        server.off('listening', onListening);
+        if (error.code === 'EADDRINUSE' && attempt < options.retryLimit) {
+          scheduleNodeListenRetry(server, attempt, options.retryDelayMs, tryListen);
+          return;
+        }
+        reject(error);
+      };
+      const onListening = () => {
+        server.off('error', onError);
+        resolve();
+      };
+      server.once('error', onError);
+      server.once('listening', onListening);
+      server.listen({
+        host: options.host,
+        port: options.port
+      });
+    };
+    tryListen(0);
+  });
+}
+function scheduleNodeListenRetry(server, attempt, retryDelayMs, tryListen) {
+  server.close(() => {
+    setTimeout(() => {
+      tryListen(attempt + 1);
+    }, retryDelayMs);
+  });
+}
+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 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;
+}

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

@@ -0,0 +1,2 @@
+export { compressNodeResponse, createNodeResponseCompression, } from './internal-node-compression.js';
+//# sourceMappingURL=node-compression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-compression.d.ts","sourceRoot":"","sources":["../../src/node/node-compression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,6BAA6B,GAC9B,MAAM,gCAAgC,CAAC"}

package/dist/node/node-compression.js

@@ -0,0 +1 @@
+export { compressNodeResponse, createNodeResponseCompression } from './internal-node-compression.js';

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

@@ -0,0 +1,2 @@
+export { createFrameworkRequest, createRequestSignal, resolveRequestIdFromHeaders, } from './internal-node-request.js';
+//# sourceMappingURL=node-request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-request.d.ts","sourceRoot":"","sources":["../../src/node/node-request.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,4BAA4B,CAAC"}

package/dist/node/node-request.js

@@ -0,0 +1 @@
+export { createFrameworkRequest, createRequestSignal, resolveRequestIdFromHeaders } from './internal-node-request.js';

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

@@ -0,0 +1,2 @@
+export { createFrameworkResponse, type MutableFrameworkResponse, writeNodeAdapterErrorResponse, } from './internal-node-response.js';
+//# sourceMappingURL=node-response.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-response.d.ts","sourceRoot":"","sources":["../../src/node/node-response.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,6BAA6B,GAC9B,MAAM,6BAA6B,CAAC"}

package/dist/node/node-response.js

@@ -0,0 +1 @@
+export { createFrameworkResponse, writeNodeAdapterErrorResponse } from './internal-node-response.js';

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

@@ -0,0 +1,2 @@
+export { createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals, } from './internal-node-shutdown.js';
+//# sourceMappingURL=node-shutdown.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-shutdown.d.ts","sourceRoot":"","sources":["../../src/node/node-shutdown.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oCAAoC,EACpC,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,6BAA6B,CAAC"}

package/dist/node/node-shutdown.js

@@ -0,0 +1 @@
+export { createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals } from './internal-node-shutdown.js';

package/dist/node/node.d.ts

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

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

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

package/dist/node/node.js

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

package/dist/node.d.ts

@@ -0,0 +1,5 @@
+export * from './logging/json-logger.js';
+export * from './logging/logger.js';
+export { bootstrapNodeApplication, createNodeHttpAdapter, NodeHttpApplicationAdapter, createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals, runNodeApplication, } from './node/internal-node.js';
+export type { BootstrapNodeApplicationOptions, CorsInput, NodeApplicationSignal, NodeHttpAdapterOptions, RunNodeApplicationOptions, } from './node/internal-node.js';
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,0BAA0B,EAC1B,oCAAoC,EACpC,0BAA0B,EAC1B,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,+BAA+B,EAC/B,SAAS,EACT,qBAAqB,EACrB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC"}

package/dist/node.js

@@ -0,0 +1,3 @@
+export * from './logging/json-logger.js';
+export * from './logging/logger.js';
+export { bootstrapNodeApplication, createNodeHttpAdapter, NodeHttpApplicationAdapter, createNodeShutdownSignalRegistration, defaultNodeShutdownSignals, registerShutdownSignals, runNodeApplication } from './node/internal-node.js';