@navios/core 1.0.0-alpha.2 → 1.0.0-alpha.4

package/lib/{index-DZ6NU03y.d.cts → index-r0i2txmg.d.cts}

@@ -1,5 +1,5 @@
 import * as _navios_di0 from "@navios/di";
-import { AnyInjectableType, ClassType, ClassTypeWithInstance, Container, FactoryContext, FactoryInjectionToken, InjectableScope, InjectionToken, Registry, ScopedContainer } from "@navios/di";
+import { AnyInjectableType, BoundInjectionToken, ClassType, ClassTypeWithArgument, ClassTypeWithInstance, Container, FactoryContext, FactoryInjectionToken, InjectableScope, InjectionToken, InjectionTokenSchemaType, Registry, ScopedContainer } from "@navios/di";
 import z, { ZodDiscriminatedUnion, ZodObject, ZodType, z as z$1 } from "zod/v4";
 import { BaseEndpointOptions, EndpointHandler, EndpointOptions, HttpMethod, RequestArgs, StreamHandler } from "@navios/builder";
 import { InspectOptions } from "util";
@@ -381,10 +381,42 @@ interface ModuleMetadata {
   guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
   overrides: Set<ClassType>;
   customAttributes: Map<string | symbol, any>;
+  /**
+   * Extensible entries for adapter-specific data.
+   * Adapters can store custom metadata using symbol keys.
+   *
+   * @example
+   * ```typescript
+   * const CommandEntryKey = Symbol('CommandEntryKey')
+   * metadata.customEntries.set(CommandEntryKey, new Set([Command1, Command2]))
+   * ```
+   */
+  customEntries: Map<symbol, unknown>;
 }
 declare function getModuleMetadata(target: ClassType, context: ClassDecoratorContext): ModuleMetadata;
 declare function extractModuleMetadata(target: ClassType): ModuleMetadata;
 declare function hasModuleMetadata(target: ClassType): boolean;
+/**
+ * Type-safe helper to get or create a custom entry in module metadata.
+ * Adapters use this to store their own metadata in modules.
+ *
+ * @param metadata - The module metadata object
+ * @param key - Symbol key for the custom entry
+ * @param defaultValue - Factory function to create default value if entry doesn't exist
+ * @returns The existing or newly created entry value
+ *
+ * @example
+ * ```typescript
+ * const CommandEntryKey = Symbol('CommandEntryKey')
+ * const commands = getModuleCustomEntry<Set<ClassType>>(
+ *   metadata,
+ *   CommandEntryKey,
+ *   () => new Set(),
+ * )
+ * commands.add(MyCommand)
+ * ```
+ */
+declare function getModuleCustomEntry<T>(metadata: ModuleMetadata, key: symbol, defaultValue: () => T): T;
 //#endregion
 //#region src/metadata/navios-managed.metadata.d.mts
 /**
@@ -415,6 +447,35 @@ declare function getManagedMetadata(target: ClassType): ManagedMetadata | null;
  */
 declare function hasManagedMetadata(target: ClassType): boolean;
 //#endregion
+//#region src/interfaces/abstract-adapter.interface.d.mts
+/**
+ * Base interface for all Navios adapters (HTTP, CLI, etc.).
+ *
+ * Adapters implement this interface to provide runtime-specific functionality.
+ * This interface defines the common lifecycle methods shared across all adapter types.
+ */
+interface AbstractAdapterInterface {
+  /**
+   * Sets up the adapter with the provided options.
+   * Called during application initialization before modules are initialized.
+   */
+  setupAdapter(options: unknown): Promise<void>;
+  /**
+   * Called after all modules are loaded.
+   * Adapters use this to register routes, commands, or other module-based functionality.
+   */
+  onModulesInit(modules: Map<string, ModuleMetadata>): Promise<void>;
+  /**
+   * Signals that the adapter is ready to handle requests/commands.
+   * Called after onModulesInit completes.
+   */
+  ready(): Promise<void>;
+  /**
+   * Disposes of the adapter and cleans up resources.
+   */
+  dispose(): Promise<void>;
+}
+//#endregion
 //#region src/interfaces/abstract-execution-context.inteface.d.mts
 /**
  * Interface providing access to the execution context during request handling.
@@ -459,6 +520,140 @@ interface AbstractExecutionContext {
   getReply(): any;
 }
 //#endregion
+//#region src/interfaces/adapter-environment.interface.d.mts
+/**
+ * Base interface for adapter environments.
+ *
+ * All adapter environments extend this interface to provide
+ * type-safe access to adapter-specific configuration options.
+ */
+interface AdapterEnvironment {
+  /**
+   * Adapter setup/configuration options type
+   */
+  options: unknown;
+  /**
+   * Adapter type
+   */
+  adapter: AbstractAdapterInterface;
+}
+/**
+ * Environment interface for HTTP adapters.
+ *
+ * Each HTTP adapter (Fastify, Bun, etc.) implements this interface to provide
+ * type-safe access to HTTP-specific types throughout the application.
+ *
+ * @example
+ * ```typescript
+ * // Using with a specific adapter
+ * import { FastifyEnvironment } from '@navios/adapter-fastify'
+ *
+ * const app = await NaviosFactory.create<FastifyEnvironment>(AppModule, {
+ *   adapter: defineFastifyEnvironment(),
+ * })
+ *
+ * // All methods are now type-safe for Fastify
+ * app.configure({ trustProxy: true })
+ * app.enableCors({ origin: true }) // FastifyCorsOptions
+ * const server = app.getServer() // FastifyInstance
+ * await app.listen({ port: 3000 }) // FastifyListenOptions
+ * ```
+ */
+interface HttpAdapterEnvironment extends AdapterEnvironment {
+  /**
+   * The underlying HTTP server instance type (e.g., FastifyInstance, Bun.Server)
+   */
+  server: unknown;
+  /**
+   * CORS configuration options type
+   */
+  corsOptions: unknown;
+  /**
+   * Multipart form data configuration options type
+   */
+  multipartOptions: unknown;
+  /**
+   * Server listen options type (port, host, etc.)
+   */
+  listenOptions: unknown;
+}
+/**
+ * Default environment with unknown types.
+ *
+ * Forces users to specify an Environment generic for type-safe adapter access.
+ * When no generic is provided to `NaviosApplication` or `NaviosFactory.create()`,
+ * this default is used, resulting in `unknown` types for all adapter-specific
+ * methods.
+ */
+interface DefaultAdapterEnvironment extends AdapterEnvironment {
+  options: unknown;
+}
+//#endregion
+//#region src/interfaces/abstract-http-adapter.interface.d.mts
+/**
+ * Interface for HTTP adapters extending the base adapter interface.
+ *
+ * Adapters implement this interface to provide runtime-specific HTTP server
+ * functionality (Fastify, Bun, etc.).
+ *
+ * @typeParam Environment - The adapter environment providing type-safe access to
+ *                          server instance, CORS options, listen options, etc.
+ */
+interface AbstractHttpAdapterInterface<Environment extends HttpAdapterEnvironment = HttpAdapterEnvironment> extends AbstractAdapterInterface {
+  /**
+   * Sets up the adapter with the provided options.
+   * Called during application initialization before modules are initialized.
+   */
+  setupAdapter(options: Environment['options']): Promise<void>;
+  /**
+   * Called after all modules are loaded to register routes.
+   */
+  onModulesInit(modules: Map<string, ModuleMetadata>): Promise<void>;
+  /**
+   * Signals that the server is ready to accept requests.
+   */
+  ready(): Promise<void>;
+  /**
+   * Disposes of the server and cleans up resources.
+   */
+  dispose(): Promise<void>;
+  /**
+   * Returns the underlying HTTP server instance.
+   */
+  getServer(): Environment['server'];
+  /**
+   * Sets a global prefix for all routes.
+   */
+  setGlobalPrefix(prefix: string): void;
+  /**
+   * Gets the current global prefix.
+   * Returns empty string if no prefix is set.
+   */
+  getGlobalPrefix(): string;
+  /**
+   * Enables CORS with the specified options.
+   */
+  enableCors(options: Environment['corsOptions']): void;
+  /**
+   * Enables multipart form data handling.
+   */
+  enableMultipart(options: Environment['multipartOptions']): void;
+  /**
+   * Starts the server and listens for incoming requests.
+   */
+  listen(options: Environment['listenOptions']): Promise<string>;
+  /**
+   * Configures the adapter with additional options before init.
+   *
+   * This method allows setting adapter-specific configuration options
+   * before the server is initialized. Options set via configure() are
+   * merged with options passed to setupAdapter().
+   *
+   * Must be called before setupAdapter().
+   */
+  configure(options: Partial<Environment['options']>): void;
+}
+//#endregion
 //#region src/logger/utils/cli-colors.util.d.mts
 declare const clc: {
   bold: (text: string) => string;
@@ -566,15 +761,46 @@ interface ConsoleLoggerOptions {
    */
   logLevels?: LogLevel[];
   /**
-   * If enabled, will print timestamp (time difference) between current and previous log message.
+   * If enabled, will print timestamp difference between current and previous log message.
    * Note: This option is not used when `json` is enabled.
+   * @default false
    */
-  timestamp?: boolean;
+  showTimeDiff?: boolean;
   /**
    * A prefix to be used for each log message.
    * Note: This option is not used when `json` is enabled.
    */
   prefix?: string;
+  /**
+   * If true, will print the process ID in the log message.
+   * Note: This option is not used when `json` is enabled.
+   * @default true
+   */
+  showPid?: boolean;
+  /**
+   * If true, will print the log level in the log message.
+   * Note: This option is not used when `json` is enabled.
+   * @default true
+   */
+  showLogLevel?: boolean;
+  /**
+   * If true, will print the prefix/app name in the log message.
+   * Note: This option is not used when `json` is enabled.
+   * @default true
+   */
+  showPrefix?: boolean;
+  /**
+   * If true, will print the context in the log message.
+   * Note: This option is not used when `json` is enabled.
+   * @default true
+   */
+  showContext?: boolean;
+  /**
+   * If true, will print the absolute timestamp in the log message.
+   * Note: This option is not used when `json` is enabled.
+   * @default true
+   */
+  showTimestamp?: boolean;
   /**
    * If enabled, will add a request ID to the log message.
    */
@@ -643,6 +869,14 @@ interface ConsoleLoggerOptions {
  * @publicApi
  */
 declare class ConsoleLogger implements LoggerService {
+  /**
+   * Creates a new ConsoleLogger instance with the given options.
+   * This is a convenience method that instantiates and sets up the logger in one call.
+   */
+  static create(): ConsoleLogger;
+  static create(context: string): ConsoleLogger;
+  static create(options: ConsoleLoggerOptions): ConsoleLogger;
+  static create(context: string, options: ConsoleLoggerOptions): ConsoleLogger;
   /**
    * The options of the logger.
    */
@@ -895,68 +1129,6 @@ interface AbstractHttpCorsOptions {
   logLevel?: LogLevel;
 }
 //#endregion
-//#region src/interfaces/abstract-http-listen-options.interface.d.mts
-interface AbstractHttpListenOptions {
-  port: number;
-  host?: string;
-}
-//#endregion
-//#region src/interfaces/abstract-http-adapter.interface.d.mts
-/**
- * Abstract interface for HTTP adapters.
- *
- * Adapters implement this interface to provide runtime-specific HTTP server
- * functionality (Fastify, Bun, etc.).
- *
- * @typeParam ServerInstance - The underlying server type (e.g., FastifyInstance)
- * @typeParam CorsOptions - CORS configuration options type
- * @typeParam Options - Server setup options type
- * @typeParam MultipartOptions - Multipart form handling options type
- */
-interface AbstractHttpAdapterInterface<ServerInstance, CorsOptions = AbstractHttpCorsOptions, Options$1 = {}, MultipartOptions = {}> {
-  /**
-   * Sets up the HTTP server with the provided options.
-   */
-  setupHttpServer(options: Options$1): Promise<void>;
-  /**
-   * Called after all modules are loaded to register routes.
-   */
-  onModulesInit(modules: Map<string, ModuleMetadata>): Promise<void>;
-  /**
-   * Signals that the server is ready to accept requests.
-   */
-  ready(): Promise<void>;
-  /**
-   * Returns the underlying HTTP server instance.
-   */
-  getServer(): ServerInstance;
-  /**
-   * Sets a global prefix for all routes.
-   */
-  setGlobalPrefix(prefix: string): void;
-  /**
-   * Gets the current global prefix.
-   * Returns empty string if no prefix is set.
-   */
-  getGlobalPrefix(): string;
-  /**
-   * Enables CORS with the specified options.
-   */
-  enableCors(options: CorsOptions): void;
-  /**
-   * Enables multipart form data handling.
-   */
-  enableMultipart(options: MultipartOptions): void;
-  /**
-   * Starts the server and listens for incoming requests.
-   */
-  listen(options: AbstractHttpListenOptions): Promise<string>;
-  /**
-   * Disposes of the server and cleans up resources.
-   */
-  dispose(): Promise<void>;
-}
-//#endregion
 //#region src/interfaces/abstract-http-handler-adapter.interface.d.mts
 /**
  * Static handler result - handler can be called without a scoped container.
@@ -979,11 +1151,88 @@ type DynamicHandler<TRequest = any, TReply = any> = {
  * Can be either static (pre-resolved) or dynamic (needs scoped container).
  */
 type HandlerResult<TRequest = any, TReply = any> = StaticHandler<TRequest, TReply> | DynamicHandler<TRequest, TReply>;
-interface AbstractHttpHandlerAdapterInterface {
-  prepareArguments?: (handlerMetadata: HandlerMetadata<any>) => ((target: Record<string, any>, request: any) => Promise<void> | void)[];
+/**
+ * Function type for argument getters that extract data from requests.
+ * Each getter populates a target object with data from the request.
+ */
+type ArgumentGetterFn<TRequest = any> = (target: Record<string, any>, request: TRequest) => void | Promise<void>;
+/**
+ * Function type for formatting arguments from a request.
+ * Built from argument getters, optimized for sync/async handling.
+ */
+type FormatArgumentsFn$1<TRequest = any> = (request: TRequest) => Record<string, any> | Promise<Record<string, any>>;
+/**
+ * Interface for HTTP handler adapter services.
+ *
+ * Adapters handle different types of HTTP requests (REST, streaming, multipart)
+ * and are responsible for:
+ * - Parsing and validating request data
+ * - Creating handler functions
+ * - Formatting responses
+ * - Providing schema information (for frameworks like Fastify)
+ */
+interface AbstractHttpHandlerAdapterInterface<TRequest = any> {
+  /**
+   * Prepares argument getters for parsing request data.
+   *
+   * Creates functions that extract and validate data from the request,
+   * populating a target object with validated arguments.
+   *
+   * @param handlerMetadata - The handler metadata with schemas and configuration.
+   * @returns An array of getter functions that populate request arguments.
+   */
+  prepareArguments?: (handlerMetadata: HandlerMetadata<any>) => ArgumentGetterFn<TRequest>[];
+  /**
+   * Builds a formatArguments function from argument getters.
+   *
+   * Automatically detects sync vs async getters and optimizes accordingly:
+   * - If all getters are sync: returns sync function (no Promise overhead)
+   * - If any getter is async: returns async function with Promise.all
+   * - If no getters: returns frozen empty object (zero allocation)
+   *
+   * This method is useful for composition-based adapters that need to
+   * build formatArguments without duplicating the optimization logic.
+   *
+   * @param getters - Array of argument getter functions
+   * @returns Function to format arguments from request
+   */
+  buildFormatArguments?: (getters: ArgumentGetterFn<TRequest>[]) => FormatArgumentsFn$1<TRequest>;
+  /**
+   * Checks if the handler has any validation schemas defined.
+   *
+   * @param handlerMetadata - The handler metadata containing configuration.
+   * @returns `true` if the handler has any schemas (request, query, response).
+   */
+  hasSchema?: (handlerMetadata: HandlerMetadata<any>) => boolean;
+  /**
+   * Provides schema information for the framework's validation system.
+   *
+   * For frameworks like Fastify, this returns route schema objects.
+   * For frameworks like Bun, this typically returns an empty object.
+   *
+   * @param handlerMetadata - The handler metadata containing configuration.
+   * @returns Schema information for framework registration.
+   */
+  provideSchema?: (handlerMetadata: HandlerMetadata<any>) => Record<string, any>;
+  /**
+   * Creates a request handler function for the endpoint.
+   *
+   * This is the core method that generates the actual handler function
+   * that will be called when a request matches the endpoint.
+   *
+   * @param controller - The controller class containing the handler method.
+   * @param handlerMetadata - The handler metadata with configuration and schemas.
+   * @returns A handler result that is either static or dynamic.
+   */
   provideHandler: (controller: ClassType, handlerMetadata: HandlerMetadata<any>) => Promise<HandlerResult>;
 }
 //#endregion
+//#region src/interfaces/abstract-http-listen-options.interface.d.mts
+interface AbstractHttpListenOptions {
+  port: number;
+  host?: string;
+}
+//#endregion
 //#region src/interfaces/can-activate.d.mts
 /**
  * Interface that guards must implement to control access to endpoints.
@@ -1124,28 +1373,40 @@ declare class ModuleLoaderService {
  * Context provided to plugins during registration.
  *
  * This context gives plugins access to the application's modules,
- * server instance, DI container, and configuration.
+ * adapter instance, DI container, and module loader.
+ *
+ * @typeParam TAdapter - The adapter type, defaults to AbstractAdapterInterface
+ *
+ * @example
+ * ```typescript
+ * // Generic plugin that works with any adapter
+ * async register(context: PluginContext) {
+ *   const modules = context.modules
+ *   // ...
+ * }
+ *
+ * // Adapter-specific plugin with typed adapter
+ * async register(context: PluginContext<BunApplicationService>) {
+ *   const server = context.adapter.getServer() // Typed as Bun.Server
+ *   // ...
+ * }
+ * ```
  */
-interface PluginContext {
+interface PluginContext<TAdapter extends AbstractAdapterInterface = AbstractAdapterInterface> {
   /**
    * All loaded modules with their metadata.
    * Keys are module class names, values are their metadata.
    */
   modules: Map<string, ModuleMetadata>;
   /**
-   * The underlying HTTP server instance.
-   * Type depends on the adapter used (Fastify, Bun, etc.)
+   * The current adapter instance.
+   * Use type guards or cast to adapter-specific types for HTTP methods.
    */
-  server: any;
+  adapter: TAdapter;
   /**
    * The dependency injection container.
    */
   container: Container;
-  /**
-   * Global route prefix (e.g., '/api/v1').
-   * Empty string if no prefix is set.
-   */
-  globalPrefix: string;
   /**
    * Module loader service for extending the module tree.
    * Use `moduleLoader.extendModules()` to add controllers dynamically.
@@ -1159,9 +1420,11 @@ interface PluginContext {
  * after all modules are loaded but before the server starts listening.
  *
  * @typeParam TOptions - The type of options the plugin accepts
+ * @typeParam TAdapter - The adapter type the plugin requires
  *
  * @example
  * ```typescript
+ * // Generic plugin
  * const myPlugin: NaviosPlugin<{ enabled: boolean }> = {
  *   name: 'my-plugin',
  *   register: async (context, options) => {
@@ -1170,9 +1433,17 @@ interface PluginContext {
  *     }
  *   },
  * }
+ *
+ * // Adapter-specific plugin
+ * const fastifyPlugin: NaviosPlugin<Options, FastifyApplicationService> = {
+ *   name: 'fastify-plugin',
+ *   register: async (context, options) => {
+ *     const fastify = context.adapter.getServer() // Typed!
+ *   },
+ * }
  * ```
  */
-interface NaviosPlugin<TOptions = unknown> {
+interface NaviosPlugin<TOptions = unknown, TAdapter extends AbstractAdapterInterface = AbstractAdapterInterface> {
   /**
    * Plugin name for identification and logging.
    */
@@ -1180,10 +1451,10 @@ interface NaviosPlugin<TOptions = unknown> {
   /**
    * Called after modules are loaded but before the server starts listening.
    *
-   * @param context - The plugin context with access to modules and server
+   * @param context - The plugin context with access to modules and adapter
    * @param options - Plugin-specific configuration options
    */
-  register(context: PluginContext, options: TOptions): Promise<void> | void;
+  register(context: PluginContext<TAdapter>, options: TOptions): Promise<void> | void;
 }
 /**
  * Plugin definition combining a plugin with its options.
@@ -1191,6 +1462,7 @@ interface NaviosPlugin<TOptions = unknown> {
  * This is the type returned by plugin factory functions like `defineOpenApiPlugin()`.
  *
  * @typeParam TOptions - The type of options the plugin accepts
+ * @typeParam TAdapter - The adapter type the plugin requires
  *
  * @example
  * ```typescript
@@ -1202,11 +1474,11 @@ interface NaviosPlugin<TOptions = unknown> {
  * }
  * ```
  */
-interface PluginDefinition<TOptions = unknown> {
+interface PluginDefinition<TOptions = unknown, TAdapter extends AbstractAdapterInterface = AbstractAdapterInterface> {
   /**
    * The plugin instance.
    */
-  plugin: NaviosPlugin<TOptions>;
+  plugin: NaviosPlugin<TOptions, TAdapter>;
   /**
    * Options to pass to the plugin's register function.
    */
@@ -2104,197 +2376,23 @@ declare const ValidationErrorResponderToken: InjectionToken<ErrorResponder, unde
  */
 declare const ForbiddenResponderToken: InjectionToken<ErrorResponder, undefined, false>;
 //#endregion
-//#region src/services/instance-resolver.service.d.mts
+//#region src/navios.environment.d.mts
+interface NaviosEnvironmentOptions {
+  tokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>;
+}
+//#endregion
+//#region src/navios.application.d.mts
 /**
- * Result of instance resolution attempt.
- * Contains either a cached singleton instance or a resolver function
- * that can be used to get a fresh instance per request.
+ * Options for configuring the Navios application context.
+ * These options control the application configuration.
  */
-interface InstanceResolution<T = any> {
+interface NaviosApplicationOptions {
   /**
-   * Whether the instance was successfully cached as a singleton.
-   * If true, `instance` contains the cached instance.
-   * If false, the class has request-scoped dependencies and
-   * must be resolved per-request using `resolve()`.
-   */
-  cached: boolean;
-  /**
-   * The cached instance (only available if `cached` is true).
-   */
-  instance: T | null;
-  /**
-   * Resolves the instance from a scoped container.
-   * Use this when `cached` is false to get a fresh instance per request.
-   */
-  resolve: (scoped: ScopedContainer) => Promise<T>;
-}
-/**
- * Result of resolving multiple instances.
- * Contains either all cached singleton instances or a resolver function.
- */
-interface MultiInstanceResolution<T = any> {
-  /**
-   * Whether ALL instances were successfully cached as singletons.
-   * If true, `instances` contains all cached instances.
-   * If false, at least one class has request-scoped dependencies.
-   */
-  cached: boolean;
-  /**
-   * The cached instances (only available if `cached` is true).
-   * Order matches the input array order.
-   */
-  instances: T[] | null;
-  /**
-   * The original class types for dynamic resolution.
-   */
-  classTypes: ClassType[];
-  /**
-   * Resolves all instances from a scoped container.
-   * Use this when `cached` is false to get fresh instances per request.
-   */
-  resolve: (scoped: ScopedContainer) => Promise<T[]>;
-}
-/**
- * Service responsible for resolving class instances with automatic scope detection.
- *
- * This service attempts to resolve classes as singletons from the root container.
- * If resolution fails (because the class has request-scoped dependencies),
- * it automatically updates the class's scope to Request and provides a
- * resolver function for per-request instantiation.
- *
- * This enables optimal performance:
- * - Classes without request-scoped deps stay as singletons (faster)
- * - Classes with request-scoped deps are automatically promoted to request scope
- *
- * @example
- * ```ts
- * const resolution = await instanceResolver.resolve(UserController)
- *
- * if (resolution.cached) {
- *   // Use cached singleton
- *   return resolution.instance.handleRequest(req)
- * } else {
- *   // Resolve per request
- *   const controller = await resolution.resolve(scopedContainer)
- *   return controller.handleRequest(req)
- * }
- * ```
- */
-declare class InstanceResolverService {
-  private container;
-  /**
-   * Attempts to resolve a class instance, automatically detecting if it needs
-   * request scope based on its dependencies.
-   *
-   * @param classType - The class to resolve
-   * @returns A resolution result containing either a cached instance or resolver function
-   */
-  resolve<T>(classType: ClassType): Promise<InstanceResolution<T>>;
-  /**
-   * Attempts to resolve multiple class instances, automatically detecting if any need
-   * request scope based on their dependencies.
-   *
-   * Returns `cached: true` only if ALL classes can be resolved as singletons.
-   * If any class has request-scoped dependencies, returns `cached: false`.
-   *
-   * @param classTypes - The classes to resolve
-   * @returns A resolution result containing either all cached instances or resolver function
-   */
-  resolveMany<T>(classTypes: ClassType[]): Promise<MultiInstanceResolution<T>>;
-}
-/**
- * @deprecated Use InstanceResolverService instead
- */
-declare const ControllerResolverService: typeof InstanceResolverService;
-/**
- * @deprecated Use InstanceResolution instead
- */
-type ControllerResolution<T = any> = InstanceResolution<T>;
-//#endregion
-//#region src/services/guard-runner.service.d.mts
-declare class GuardRunnerService {
-  private readonly errorProducer;
-  private readonly logger;
-  /**
-   * Runs guards that need to be resolved from a scoped container.
-   * Use this when guards have request-scoped dependencies.
-   */
-  runGuards(allGuards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>, executionContext: AbstractExecutionContext, context: ScopedContainer): Promise<boolean>;
-  /**
-   * Runs pre-resolved guard instances.
-   * Use this when all guards are singletons and have been pre-resolved at startup.
-   */
-  runGuardsStatic(guardInstances: CanActivate[], executionContext: AbstractExecutionContext): Promise<boolean>;
-  /**
-   * Shared guard execution logic.
-   * Iterates through guard instances and calls canActivate on each.
-   */
-  private executeGuards;
-  makeContext(moduleMetadata: ModuleMetadata, controllerMetadata: ControllerMetadata, endpoint: HandlerMetadata): Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
-}
-//#endregion
-//#region src/stores/request-id.store.d.mts
-/**
- * Generates a simple incremental request ID.
- * Much faster than crypto.randomUUID() and sufficient for request tracking.
- *
- * @returns A unique request ID string (e.g., "req-1", "req-2", ...)
- */
-declare function generateRequestId(): string;
-/**
- * Enables or disables request ID propagation.
- * Called by NaviosFactory based on the enableRequestId option.
- *
- * @param enabled - Whether to enable request ID propagation
- */
-declare function setRequestIdEnabled(enabled: boolean): void;
-/**
- * Runs a function with a request ID in the async local storage context.
- * If request ID propagation is disabled, the function is called directly
- * without AsyncLocalStorage overhead.
- *
- * @param requestId - The request ID to set for this context
- * @param fn - The function to run within this context
- * @returns The return value of the function
- */
-declare function runWithRequestId<R>(requestId: string, fn: () => R): R;
-/**
- * Gets the current request ID from the async local storage context.
- *
- * @returns The current request ID, or undefined if not in a request context
- */
-declare function getRequestId(): string | undefined;
-//#endregion
-//#region src/tokens/endpoint-adapter.token.d.mts
-declare const EndpointAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
-//#endregion
-//#region src/tokens/execution-context.token.d.mts
-declare const ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
-declare const ExecutionContext: InjectionToken<AbstractExecutionContext, undefined, false>;
-//#endregion
-//#region src/tokens/http-adapter.token.d.mts
-declare const HttpAdapterToken: InjectionToken<AbstractHttpAdapterInterface<any, any, any, any>, undefined, false>;
-//#endregion
-//#region src/tokens/multipart-adapter.token.d.mts
-declare const MultipartAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
-//#endregion
-//#region src/navios.environment.d.mts
-interface NaviosEnvironmentOptions {
-  httpTokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>;
-}
-//#endregion
-//#region src/navios.application.d.mts
-/**
- * Options for configuring the Navios application context.
- * These options control the application configuration.
- */
-interface NaviosApplicationOptions {
-  /**
-   * Specifies the logger to use. Pass `false` to turn off logging.
-   *
-   * - `LoggerService` instance: Use a custom logger implementation
-   * - `LogLevel[]`: Enable specific log levels (e.g., ['error', 'warn', 'log'])
-   * - `false`: Disable logging completely
+   * Specifies the logger to use. Pass `false` to turn off logging.
+   *
+   * - `LoggerService` instance: Use a custom logger implementation
+   * - `LogLevel[]`: Enable specific log levels (e.g., ['error', 'warn', 'log'])
+   * - `false`: Disable logging completely
    */
   logger?: LoggerService | LogLevel[] | false;
   /**
@@ -2308,14 +2406,14 @@ interface NaviosApplicationOptions {
    */
   container?: Container;
   /**
-   * HTTP adapter environment(s) to use for the application.
+   * Adapter environment(s) to use for the application.
    * Can be a single adapter or an array of adapters.
    *
    * @example
    * ```typescript
    * adapter: defineFastifyEnvironment()
    * // or
-   * adapter: [defineFastifyEnvironment(), defineBunEnvironment()]
+   * adapter: [defineFastifyEnvironment()]
    * ```
    */
   adapter: NaviosEnvironmentOptions | NaviosEnvironmentOptions[];
@@ -2336,7 +2434,7 @@ interface NaviosApplicationOptions {
  * Main application class for Navios.
  *
  * This class represents a Navios application instance and provides methods
- * for initializing, configuring, and managing the HTTP server.
+ * for initializing, configuring, and managing the application lifecycle.
  *
  * @example
  * ```typescript
@@ -2350,10 +2448,10 @@ interface NaviosApplicationOptions {
  * await app.listen({ port: 3000, host: '0.0.0.0' })
  * ```
  */
-declare class NaviosApplication {
+declare class NaviosApplication<Environment extends AdapterEnvironment = DefaultAdapterEnvironment> {
   private environment;
   private moduleLoader;
-  private httpApplication;
+  private adapter;
   private logger;
   protected container: Container;
   private appModule;
@@ -2379,6 +2477,13 @@ declare class NaviosApplication {
    * @returns The Container instance
    */
   getContainer(): Container;
+  /**
+   * Returns the current adapter instance.
+   *
+   * @returns The adapter instance
+   * @throws Error if adapter is not initialized
+   */
+  getAdapter(): Environment['adapter'];
   /**
    * Registers a plugin to be initialized after modules are loaded.
    *
@@ -2397,13 +2502,13 @@ declare class NaviosApplication {
    * }))
    * ```
    */
-  usePlugin<TOptions>(definition: PluginDefinition<TOptions>): this;
+  usePlugin<TOptions, TAdapter extends AbstractAdapterInterface>(definition: PluginDefinition<TOptions, TAdapter>): this;
   /**
    * Initializes the application.
    *
    * This method:
    * - Loads all modules and their dependencies
-   * - Sets up the HTTP server if an adapter is configured
+   * - Sets up the adapter if one is configured
    * - Calls onModuleInit hooks on all modules
    * - Initializes registered plugins
    * - Marks the application as initialized
@@ -2424,11 +2529,52 @@ declare class NaviosApplication {
   init(): Promise<void>;
   private initModules;
   private initPlugins;
+  /**
+   * Gets a service instance from the dependency injection container.
+   *
+   * This is a shorthand for `app.getContainer().get(token)`.
+   *
+   * @param token - The injection token or class to resolve
+   * @returns Promise resolving to the service instance
+   *
+   * @example
+   * ```typescript
+   * const userService = await app.get(UserService)
+   * const config = await app.get(ConfigToken)
+   * ```
+   */
+  get<T extends ClassType>(token: T): Promise<InstanceType<T>>;
+  get<T extends ClassTypeWithArgument<R>, R>(token: T, args: R): Promise<InstanceType<T>>;
+  get<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z$1.input<S>): Promise<T>;
+  get<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): Promise<T>;
+  get<T>(token: InjectionToken<T, undefined>): Promise<T>;
+  get<T>(token: BoundInjectionToken<T, any>): Promise<T>;
+  get<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
+  /**
+   * Configures the adapter with additional options before initialization.
+   *
+   * This method allows setting adapter-specific configuration options
+   * before the adapter is initialized. Must be called before `init()`.
+   *
+   * @param options - Adapter-specific configuration options
+   * @returns this for method chaining
+   * @throws Error if called after init() or if adapter doesn't support configure
+   *
+   * @example
+   * ```typescript
+   * // With Fastify adapter
+   * app.configure({ trustProxy: true, logger: true })
+   *
+   * // With Bun adapter
+   * app.configure({ development: true })
+   * ```
+   */
+  configure(options: Partial<Environment['options']>): this;
   /**
    * Enables CORS (Cross-Origin Resource Sharing) for the application.
    *
    * @param options - CORS configuration options (adapter-specific)
-   * @throws Error if HTTP application is not set
+   * @throws Error if adapter doesn't support enableCors
    *
    * @example
    * ```typescript
@@ -2439,12 +2585,12 @@ declare class NaviosApplication {
    * })
    * ```
    */
-  enableCors(options: any): void;
+  enableCors(options: Environment extends HttpAdapterEnvironment ? Environment['corsOptions'] : never): void;
   /**
    * Enables multipart/form-data support for file uploads.
    *
    * @param options - Multipart configuration options (adapter-specific)
-   * @throws Error if HTTP application is not set
+   * @throws Error if adapter doesn't support enableMultipart
    *
    * @example
    * ```typescript
@@ -2455,12 +2601,12 @@ declare class NaviosApplication {
    * })
    * ```
    */
-  enableMultipart(options: any): void;
+  enableMultipart(options: Environment extends HttpAdapterEnvironment ? Environment['multipartOptions'] : never): void;
   /**
    * Sets a global prefix for all routes.
    *
    * @param prefix - The prefix to prepend to all route URLs (e.g., '/api')
-   * @throws Error if HTTP application is not set
+   * @throws Error if adapter doesn't support setGlobalPrefix
    *
    * @example
    * ```typescript
@@ -2477,7 +2623,7 @@ declare class NaviosApplication {
    * - Bun adapter: Returns Bun.Server
    *
    * @returns The HTTP server instance
-   * @throws Error if HTTP application is not set
+   * @throws Error if adapter doesn't support getServer
    *
    * @example
    * ```typescript
@@ -2485,23 +2631,23 @@ declare class NaviosApplication {
    * // Use adapter-specific server methods
    * ```
    */
-  getServer(): any;
+  getServer(): Environment extends HttpAdapterEnvironment ? Environment['server'] : never;
   /**
    * Starts the HTTP server and begins listening for requests.
    *
    * @param options - Listen options (port, host, etc.)
-   * @throws Error if HTTP application is not set
+   * @throws Error if adapter doesn't support listen
    *
    * @example
    * ```typescript
    * await app.listen({ port: 3000, host: '0.0.0.0' })
    * ```
    */
-  listen(options: AbstractHttpListenOptions): Promise<void>;
+  listen(options: Environment extends HttpAdapterEnvironment ? Environment['listenOptions'] : never): Promise<string>;
   /**
    * Disposes of application resources.
    *
-   * Cleans up the HTTP server and module loader.
+   * Cleans up the adapter and module loader.
    * This method is called automatically by `close()`.
    */
   dispose(): Promise<void>;
@@ -2522,6 +2668,367 @@ declare class NaviosApplication {
   close(): Promise<void>;
 }
 //#endregion
+//#region src/services/instance-resolver.service.d.mts
+/**
+ * Result of instance resolution attempt.
+ * Contains either a cached singleton instance or a resolver function
+ * that can be used to get a fresh instance per request.
+ */
+interface InstanceResolution<T = any> {
+  /**
+   * Whether the instance was successfully cached as a singleton.
+   * If true, `instance` contains the cached instance.
+   * If false, the class has request-scoped dependencies and
+   * must be resolved per-request using `resolve()`.
+   */
+  cached: boolean;
+  /**
+   * The cached instance (only available if `cached` is true).
+   */
+  instance: T | null;
+  /**
+   * Resolves the instance from a scoped container.
+   * Use this when `cached` is false to get a fresh instance per request.
+   */
+  resolve: (scoped: ScopedContainer) => Promise<T>;
+}
+/**
+ * Result of resolving multiple instances.
+ * Contains either all cached singleton instances or a resolver function.
+ */
+interface MultiInstanceResolution<T = any> {
+  /**
+   * Whether ALL instances were successfully cached as singletons.
+   * If true, `instances` contains all cached instances.
+   * If false, at least one class has request-scoped dependencies.
+   */
+  cached: boolean;
+  /**
+   * The cached instances (only available if `cached` is true).
+   * Order matches the input array order.
+   */
+  instances: T[] | null;
+  /**
+   * The original class types for dynamic resolution.
+   */
+  classTypes: ClassType[];
+  /**
+   * Resolves all instances from a scoped container.
+   * Use this when `cached` is false to get fresh instances per request.
+   */
+  resolve: (scoped: ScopedContainer) => Promise<T[]>;
+}
+/**
+ * Service responsible for resolving class instances with automatic scope detection.
+ *
+ * This service attempts to resolve classes as singletons from the root container.
+ * If resolution fails (because the class has request-scoped dependencies),
+ * it automatically updates the class's scope to Request and provides a
+ * resolver function for per-request instantiation.
+ *
+ * This enables optimal performance:
+ * - Classes without request-scoped deps stay as singletons (faster)
+ * - Classes with request-scoped deps are automatically promoted to request scope
+ *
+ * @example
+ * ```ts
+ * const resolution = await instanceResolver.resolve(UserController)
+ *
+ * if (resolution.cached) {
+ *   // Use cached singleton
+ *   return resolution.instance.handleRequest(req)
+ * } else {
+ *   // Resolve per request
+ *   const controller = await resolution.resolve(scopedContainer)
+ *   return controller.handleRequest(req)
+ * }
+ * ```
+ */
+declare class InstanceResolverService {
+  private container;
+  /**
+   * Attempts to resolve a class instance, automatically detecting if it needs
+   * request scope based on its dependencies.
+   *
+   * @param classType - The class to resolve
+   * @returns A resolution result containing either a cached instance or resolver function
+   */
+  resolve<T>(classType: ClassType): Promise<InstanceResolution<T>>;
+  /**
+   * Attempts to resolve multiple class instances, automatically detecting if any need
+   * request scope based on their dependencies.
+   *
+   * Returns `cached: true` only if ALL classes can be resolved as singletons.
+   * If any class has request-scoped dependencies, returns `cached: false`.
+   *
+   * @param classTypes - The classes to resolve
+   * @returns A resolution result containing either all cached instances or resolver function
+   */
+  resolveMany<T>(classTypes: ClassType[]): Promise<MultiInstanceResolution<T>>;
+}
+/**
+ * @deprecated Use InstanceResolverService instead
+ */
+declare const ControllerResolverService: typeof InstanceResolverService;
+/**
+ * @deprecated Use InstanceResolution instead
+ */
+type ControllerResolution<T = any> = InstanceResolution<T>;
+//#endregion
+//#region src/services/abstract-handler-adapter.service.d.mts
+/**
+ * Function type for argument getters that extract data from requests.
+ * Re-exported from interface for convenience in adapter implementations.
+ */
+type ArgumentGetter<TRequest> = ArgumentGetterFn<TRequest>;
+/**
+ * Internal alias for FormatArgumentsFn from interface.
+ * Not re-exported to avoid duplicate exports - use FormatArgumentsFn from interfaces instead.
+ */
+type FormatArgumentsFn<TRequest> = FormatArgumentsFn$1<TRequest>;
+/**
+ * Static handler - can be called without a scoped container.
+ */
+type AbstractStaticHandler<TRequest, TReply = void> = {
+  isStatic: true;
+  handler: (request: TRequest, reply: TReply) => Promise<any>;
+};
+/**
+ * Dynamic handler - requires a scoped container for resolution.
+ */
+type AbstractDynamicHandler<TRequest, TReply = void> = {
+  isStatic: false;
+  handler: (scoped: ScopedContainer, request: TRequest, reply: TReply) => Promise<any>;
+};
+/**
+ * Handler result - either static or dynamic.
+ */
+type AbstractHandlerResult<TRequest, TReply = void> = AbstractStaticHandler<TRequest, TReply> | AbstractDynamicHandler<TRequest, TReply>;
+/**
+ * Context passed to handler creation methods.
+ */
+interface HandlerContext<TConfig extends BaseEndpointOptions = BaseEndpointOptions> {
+  methodName: string;
+  statusCode: number;
+  headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>;
+  handlerMetadata: HandlerMetadata<TConfig>;
+  hasArguments: boolean;
+}
+/**
+ * Abstract base class for HTTP handler adapter services.
+ *
+ * Provides shared logic for:
+ * - Controller resolution (singleton vs request-scoped)
+ * - Argument formatting (sync/async detection)
+ * - Handler generation with static/dynamic branching
+ * - Standardized error handling
+ *
+ * Adapters implement abstract methods for framework-specific behavior:
+ * - Request parsing (query, body, URL params)
+ * - Response creation
+ * - Schema provision
+ *
+ * Supports all adapter types:
+ * - Endpoint adapters: JSON request/response with validation
+ * - Stream adapters: Streaming responses with extra context
+ * - Multipart adapters: Form data parsing (extends endpoint)
+ *
+ * @typeParam TRequest - Framework request type (BunRequest, FastifyRequest)
+ * @typeParam TReply - Framework reply type (void for Bun, FastifyReply)
+ * @typeParam TConfig - Endpoint configuration type
+ */
+declare abstract class AbstractHandlerAdapterService<TRequest, TReply = void, TConfig extends BaseEndpointOptions = BaseEndpointOptions> {
+  protected instanceResolver: InstanceResolverService;
+  protected options: NaviosApplicationOptions;
+  /**
+   * Creates argument getter functions for extracting data from requests.
+   *
+   * Each getter populates a target object with data from the request
+   * (query params, body, URL params, etc.).
+   *
+   * Implementation varies by adapter type:
+   * - Endpoint: JSON body parsing with schema validation
+   * - Stream: Same as endpoint (body + query + url params)
+   * - Multipart: FormData/multipart stream parsing
+   *
+   * @param handlerMetadata - Handler metadata with schemas and configuration
+   * @returns Array of getter functions
+   */
+  protected abstract createArgumentGetters(handlerMetadata: HandlerMetadata<TConfig>): ArgumentGetter<TRequest>[];
+  /**
+   * Creates a static handler for singleton controllers.
+   *
+   * Implementation varies by adapter type:
+   * - Endpoint: Invoke method(args), serialize response as JSON
+   * - Stream: Invoke method(args, streamContext), return Response/use reply
+   *
+   * @param boundMethod - Pre-bound controller method
+   * @param formatArguments - Function to format request arguments
+   * @param context - Handler context with metadata
+   * @returns Static handler result
+   */
+  protected abstract createStaticHandler(boundMethod: (...args: any[]) => Promise<any>, formatArguments: FormatArgumentsFn<TRequest>, context: HandlerContext<TConfig>): AbstractStaticHandler<TRequest, TReply>;
+  /**
+   * Creates a dynamic handler for request-scoped controllers.
+   *
+   * Implementation varies by adapter type:
+   * - Endpoint: Resolve controller per-request, invoke method(args)
+   * - Stream: Resolve controller per-request, invoke method(args, streamContext)
+   *
+   * @param resolution - Instance resolution with resolve function
+   * @param formatArguments - Function to format request arguments
+   * @param context - Handler context with metadata
+   * @returns Dynamic handler result
+   */
+  protected abstract createDynamicHandler(resolution: InstanceResolution, formatArguments: FormatArgumentsFn<TRequest>, context: HandlerContext<TConfig>): AbstractDynamicHandler<TRequest, TReply>;
+  /**
+   * Prepares argument getters for parsing request data.
+   *
+   * Public alias for createArgumentGetters to satisfy interface contracts.
+   * Subclasses should override createArgumentGetters instead.
+   *
+   * @param handlerMetadata - Handler metadata with schemas and configuration
+   * @returns Array of getter functions
+   */
+  prepareArguments(handlerMetadata: HandlerMetadata<TConfig>): ArgumentGetter<TRequest>[];
+  /**
+   * Checks if the handler has any validation schemas defined.
+   *
+   * Override in subclasses to add additional schema checks
+   * (e.g., response schema validation for endpoint adapters).
+   *
+   * @param handlerMetadata - Handler metadata with configuration
+   * @returns true if handler has schemas
+   */
+  hasSchema(handlerMetadata: HandlerMetadata<TConfig>): boolean;
+  /**
+   * Provides schema information for the framework's validation system.
+   *
+   * Override in subclasses for frameworks that support schema registration
+   * (e.g., Fastify). Default returns empty object (suitable for Bun).
+   *
+   * @param handlerMetadata - Handler metadata with configuration
+   * @returns Schema object for framework registration
+   */
+  provideSchema(_handlerMetadata: HandlerMetadata<TConfig>): Record<string, any>;
+  /**
+   * Creates a request handler function for the endpoint.
+   *
+   * This method orchestrates the entire handler creation:
+   * 1. Prepares argument getters for request parsing
+   * 2. Builds optimized formatArguments function (sync/async)
+   * 3. Resolves the controller (singleton vs request-scoped)
+   * 4. Creates appropriate handler (static or dynamic)
+   *
+   * @param controller - Controller class containing the handler method
+   * @param handlerMetadata - Handler metadata with configuration
+   * @returns Handler result (static or dynamic)
+   */
+  provideHandler(controller: ClassType, handlerMetadata: HandlerMetadata<TConfig>): Promise<AbstractHandlerResult<TRequest, TReply>>;
+  /**
+   * Builds a formatArguments function from argument getters.
+   *
+   * Automatically detects sync vs async getters and optimizes accordingly:
+   * - If all getters are sync: returns sync function (no Promise overhead)
+   * - If any getter is async: returns async function with Promise.all
+   * - If no getters: returns frozen empty object (zero allocation)
+   *
+   * This method is public to allow composition-based adapters (like XML adapter)
+   * to reuse the optimized formatArguments logic without inheritance.
+   *
+   * @param getters - Array of argument getter functions
+   * @returns Function to format arguments from request
+   */
+  buildFormatArguments(getters: ArgumentGetter<TRequest>[]): FormatArgumentsFn<TRequest>;
+  /**
+   * Checks if the URL pattern contains URL parameters.
+   *
+   * @param config - Endpoint configuration
+   * @returns true if URL contains '$' parameter markers
+   */
+  protected hasUrlParams(config: TConfig): boolean;
+  /**
+   * Wraps handler execution with standardized error handling.
+   *
+   * Re-throws HttpExceptions as-is for framework error handlers.
+   * Other errors are re-thrown for global error handling.
+   *
+   * @param fn - Handler function to wrap
+   * @returns Wrapped function with error handling
+   */
+  protected wrapWithErrorHandling<T extends (...args: any[]) => Promise<any>>(fn: T): T;
+}
+//#endregion
+//#region src/services/guard-runner.service.d.mts
+declare class GuardRunnerService {
+  private readonly errorProducer;
+  private readonly logger;
+  /**
+   * Runs guards that need to be resolved from a scoped container.
+   * Use this when guards have request-scoped dependencies.
+   */
+  runGuards(allGuards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>, executionContext: AbstractExecutionContext, context: ScopedContainer): Promise<boolean>;
+  /**
+   * Runs pre-resolved guard instances.
+   * Use this when all guards are singletons and have been pre-resolved at startup.
+   */
+  runGuardsStatic(guardInstances: CanActivate[], executionContext: AbstractExecutionContext): Promise<boolean>;
+  /**
+   * Shared guard execution logic.
+   * Iterates through guard instances and calls canActivate on each.
+   */
+  private executeGuards;
+  makeContext(moduleMetadata: ModuleMetadata, controllerMetadata: ControllerMetadata, endpoint: HandlerMetadata): Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+}
+//#endregion
+//#region src/stores/request-id.store.d.mts
+/**
+ * Generates a simple incremental request ID.
+ * Much faster than crypto.randomUUID() and sufficient for request tracking.
+ *
+ * @returns A unique request ID string (e.g., "req-1", "req-2", ...)
+ */
+declare function generateRequestId(): string;
+/**
+ * Enables or disables request ID propagation.
+ * Called by NaviosFactory based on the enableRequestId option.
+ *
+ * @param enabled - Whether to enable request ID propagation
+ */
+declare function setRequestIdEnabled(enabled: boolean): void;
+/**
+ * Runs a function with a request ID in the async local storage context.
+ * If request ID propagation is disabled, the function is called directly
+ * without AsyncLocalStorage overhead.
+ *
+ * @param requestId - The request ID to set for this context
+ * @param fn - The function to run within this context
+ * @returns The return value of the function
+ */
+declare function runWithRequestId<R>(requestId: string, fn: () => R): R;
+/**
+ * Gets the current request ID from the async local storage context.
+ *
+ * @returns The current request ID, or undefined if not in a request context
+ */
+declare function getRequestId(): string | undefined;
+//#endregion
+//#region src/tokens/adapter.token.d.mts
+declare const AdapterToken: InjectionToken<AbstractAdapterInterface, undefined, false>;
+//#endregion
+//#region src/tokens/endpoint-adapter.token.d.mts
+declare const EndpointAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface<any>, undefined, false>;
+//#endregion
+//#region src/tokens/execution-context.token.d.mts
+declare const ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+declare const ExecutionContext: InjectionToken<AbstractExecutionContext, undefined, false>;
+//#endregion
+//#region src/tokens/http-adapter.token.d.mts
+declare const HttpAdapterToken: InjectionToken<AbstractHttpAdapterInterface<HttpAdapterEnvironment>, undefined, false>;
+//#endregion
+//#region src/tokens/multipart-adapter.token.d.mts
+declare const MultipartAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface<any>, undefined, false>;
+//#endregion
 //#region src/tokens/navios-options.token.d.mts
 declare const NaviosOptionsToken: InjectionToken<NaviosApplicationOptions, undefined, false>;
 //#endregion
@@ -2532,10 +3039,35 @@ declare const Reply: InjectionToken<any, undefined, false>;
 declare const Request: InjectionToken<any, undefined, false>;
 //#endregion
 //#region src/tokens/stream-adapter.token.d.mts
-declare const StreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+declare const StreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface<any>, undefined, false>;
 //#endregion
 //#region src/tokens/xml-stream-adapter.token.d.mts
-declare const XmlStreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+declare const XmlStreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface<any>, undefined, false>;
+//#endregion
+//#region src/utils/adapter-supports.util.d.mts
+/**
+ * Type guard to check if adapter implements a specific method.
+ * Narrows the adapter type to include the method.
+ *
+ * @example
+ * ```typescript
+ * if (adapterSupports(adapter, 'getServer')) {
+ *   const server = adapter.getServer() // TypeScript knows this exists
+ * }
+ * ```
+ */
+declare function adapterSupports<TAdapter extends AbstractAdapterInterface, TMethod extends string>(adapter: TAdapter | null, method: TMethod): adapter is TAdapter & Record<TMethod, (...args: unknown[]) => unknown>;
+/**
+ * Asserts adapter supports a method, throws if not.
+ * Narrows type after assertion.
+ *
+ * @example
+ * ```typescript
+ * assertAdapterSupports(adapter, 'enableCors')
+ * adapter.enableCors(options) // TypeScript knows this exists
+ * ```
+ */
+declare function assertAdapterSupports<TAdapter extends AbstractAdapterInterface, TMethod extends string>(adapter: TAdapter | null, method: TMethod): asserts adapter is TAdapter & Record<TMethod, (...args: unknown[]) => unknown>;
 //#endregion
 //#region src/attribute.factory.d.mts
 /**
@@ -2711,6 +3243,12 @@ declare class AttributeFactory {
   static has<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): boolean;
 }
 //#endregion
+//#region src/factories/adapter.factory.d.mts
+declare class AdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
 //#region src/factories/endpoint-adapter.factory.d.mts
 declare class EndpointAdapterFactory {
   private readonly environment;
@@ -2779,12 +3317,16 @@ declare class NaviosFactory {
   /**
    * Creates a new Navios application instance.
    *
-   * This method sets up the dependency injection container, registers the HTTP adapter,
+   * This method sets up the dependency injection container, registers the adapter,
    * configures logging, and initializes the application with the provided module.
    *
+   * @typeParam Environment - Adapter environment interface for type-safe access
+   *   to adapter-specific features. When specified, methods like `getServer()`,
+   *   `enableCors()`, `listen()`, and `configure()` will have proper types.
+   *
    * @param appModule - The root application module class decorated with @Module()
    * @param options - Configuration options for the application
-   * @param options.adapter - HTTP adapter environment (required for HTTP server functionality)
+   * @param options.adapter - Adapter environment (required for server functionality)
    * @param options.logger - Logger configuration. Can be:
    *   - A LoggerService instance for custom logging
    *   - An array of LogLevel strings to enable specific log levels
@@ -2799,6 +3341,15 @@ declare class NaviosFactory {
    *   adapter: defineFastifyEnvironment(),
    * })
    *
+   * // Type-safe setup with Fastify environment
+   * import { FastifyEnvironment } from '@navios/adapter-fastify'
+   *
+   * const app = await NaviosFactory.create<FastifyEnvironment>(AppModule, {
+   *   adapter: defineFastifyEnvironment(),
+   * })
+   * app.configure({ trustProxy: true })
+   * const server = app.getServer() // FastifyInstance
+   *
    * // With custom logger configuration
    * const app = await NaviosFactory.create(AppModule, {
    *   adapter: defineFastifyEnvironment(),
@@ -2813,10 +3364,10 @@ declare class NaviosFactory {
    * })
    * ```
    */
-  static create(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<NaviosApplication>;
+  static create<Environment extends AdapterEnvironment = DefaultAdapterEnvironment>(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<NaviosApplication<Environment>>;
   private static registerEnvironment;
   private static registerLoggerConfiguration;
 }
 //#endregion
-export { HttpException as $, yellow as $t, ControllerResolverService as A, ConfigServiceToken as An, LoggerInstance as At, InternalServerErrorResponderService as B, isObject as Bt, EndpointAdapterToken as C, ControllerOptions as Cn, AbstractHttpAdapterInterface as Ct, setRequestIdEnabled as D, ConfigService as Dn, LoggerOptions as Dt, runWithRequestId as E, provideConfig as En, Logger as Et, InternalServerErrorResponderToken as F, PathValue as Fn, isConstructor as Ft, ProblemDetails as G, normalizePath as Gt, ErrorResponseProducerService as H, isString as Ht, NotFoundResponderToken as I, envInt as In, isEmpty as It, UnauthorizedException as J, isLogLevel as Jt, FrameworkError as K, stripEndSlash as Kt, ValidationErrorResponderToken as L, envString as Ln, isFunction as Lt, InstanceResolverService as M, Path as Mn, ConsoleLoggerOptions as Mt, MultiInstanceResolution as N, PathImpl as Nn, LoggerService as Nt, GuardRunnerService as O, ConfigServiceOptions as On, LoggerOutput as Ot, ForbiddenResponderToken as P, PathImpl2 as Pn, addLeadingSlash as Pt, BadRequestException as Q, clc as Qt, ValidationErrorResponderService as R, isNil as Rt, ExecutionContextInjectionToken as S, Controller as Sn, StaticHandler as St, getRequestId as T, EnvConfigProvider as Tn, AbstractHttpCorsOptions as Tt, ErrorResponder as U, isSymbol as Ut, ForbiddenResponderService as V, isPlainObject as Vt, ErrorResponse as W, isUndefined as Wt, InternalServerErrorException as X, LOG_LEVELS as Xt, NotFoundException as Y, filterLogLevels as Yt, ForbiddenException as Z, LogLevel as Zt, NaviosApplication as _, getAllEndpointMetadata as _n, OmitIndexSignature as _t, RequestFactory as a, ModuleMetadata as an, MultipartResult as at, HttpAdapterToken as b, EndpointParams as bn, DynamicHandler as bt, EndpointAdapterFactory as c, getModuleMetadata as cn, HttpCode as ct, ClassSchemaAttribute as d, ControllerMetadataKey as dn, PluginContext as dt, AbstractExecutionContext as en, UseGuards as et, XmlStreamAdapterToken as f, extractControllerMetadata as fn, PluginDefinition as ft, NaviosOptionsToken as g, HandlerMetadata as gn, HttpHeader as gt, Reply as h, EndpointMetadataKey as hn, NaviosModule as ht, ReplyFactory as i, hasManagedMetadata as in, MultipartParams as it, InstanceResolution as j, ConfigServiceInterface as jn, ConsoleLogger as jt, ControllerResolution as k, ConfigServiceOptionsSchema as kn, loggerOptionsSchema as kt, AttributeFactory as l, hasModuleMetadata as ln, Header as lt, Request as m, hasControllerMetadata as mn, ModuleLoaderService as mt, XmlStreamAdapterFactory as n, NaviosManagedMetadataKey as nn, StreamParams as nt, MultipartAdapterFactory as o, ModuleMetadataKey as on, Module as ot, StreamAdapterToken as p, getControllerMetadata as pn, ModuleExtension as pt, ConflictException as q, isLogLevelEnabled as qt, StreamAdapterFactory as r, getManagedMetadata as rn, Multipart as rt, HttpAdapterFactory as s, extractModuleMetadata as sn, ModuleOptions as st, NaviosFactory as t, ManagedMetadata as tn, Stream as tt, ClassAttribute as u, ControllerMetadata as un, NaviosPlugin as ut, NaviosApplicationOptions as v, getEndpointMetadata as vn, CanActivate as vt, generateRequestId as w, ConfigProviderOptions as wn, AbstractHttpListenOptions as wt, ExecutionContext as x, EndpointResult as xn, HandlerResult as xt, MultipartAdapterToken as y, Endpoint as yn, AbstractHttpHandlerAdapterInterface as yt, NotFoundResponderService as z, isNumber as zt };
-//# sourceMappingURL=index-DZ6NU03y.d.cts.map
+export { ErrorResponder as $, envInt as $n, isString as $t, GuardRunnerService as A, getControllerMetadata as An, AbstractHttpHandlerAdapterInterface as At, InstanceResolverService as B, ControllerOptions as Bn, loggerOptionsSchema as Bt, ExecutionContextInjectionToken as C, extractModuleMetadata as Cn, ModuleExtension as Ct, getRequestId as D, ControllerMetadata as Dn, OmitIndexSignature as Dt, generateRequestId as E, hasModuleMetadata as En, HttpHeader as Et, ArgumentGetter as F, getEndpointMetadata as Fn, StaticHandler as Ft, InternalServerErrorResponderToken as G, ConfigServiceOptions as Gn, addLeadingSlash as Gt, NaviosApplication as H, EnvConfigProvider as Hn, ConsoleLogger as Ht, HandlerContext as I, Endpoint as In, AbstractHttpCorsOptions as It, ValidationErrorResponderService as J, ConfigServiceInterface as Jn, isFunction as Jt, NotFoundResponderToken as K, ConfigServiceOptionsSchema as Kn, isConstructor as Kt, ControllerResolution as L, EndpointParams as Ln, Logger as Lt, AbstractHandlerAdapterService as M, EndpointMetadataKey as Mn, DynamicHandler as Mt, AbstractHandlerResult as N, HandlerMetadata as Nn, FormatArgumentsFn$1 as Nt, runWithRequestId as O, ControllerMetadataKey as On, CanActivate as Ot, AbstractStaticHandler as P, getAllEndpointMetadata as Pn, HandlerResult as Pt, ErrorResponseProducerService as Q, PathValue as Qn, isPlainObject as Qt, ControllerResolverService as R, EndpointResult as Rn, LoggerOptions as Rt, ExecutionContext as S, ModuleMetadataKey as Sn, PluginDefinition as St, AdapterToken as T, getModuleMetadata as Tn, NaviosModule as Tt, NaviosApplicationOptions as U, provideConfig as Un, ConsoleLoggerOptions as Ut, MultiInstanceResolution as V, ConfigProviderOptions as Vn, LoggerInstance as Vt, ForbiddenResponderToken as W, ConfigService as Wn, LoggerService as Wt, InternalServerErrorResponderService as X, PathImpl as Xn, isNumber as Xt, NotFoundResponderService as Y, Path as Yn, isNil as Yt, ForbiddenResponderService as Z, PathImpl2 as Zn, isObject as Zt, Request as _, ManagedMetadata as _n, ModuleOptions as _t, RequestFactory as a, isLogLevel as an, NotFoundException as at, MultipartAdapterToken as b, hasManagedMetadata as bn, NaviosPlugin as bt, EndpointAdapterFactory as c, LogLevel as cn, BadRequestException as ct, ClassAttribute as d, AbstractHttpAdapterInterface as dn, Stream as dt, isSymbol as en, envString as er, ErrorResponse as et, ClassSchemaAttribute as f, AdapterEnvironment as fn, StreamParams as ft, StreamAdapterToken as g, AbstractAdapterInterface as gn, Module as gt, XmlStreamAdapterToken as h, AbstractExecutionContext as hn, MultipartResult as ht, ReplyFactory as i, isLogLevelEnabled as in, UnauthorizedException as it, AbstractDynamicHandler as j, hasControllerMetadata as jn, ArgumentGetterFn as jt, setRequestIdEnabled as k, extractControllerMetadata as kn, AbstractHttpListenOptions as kt, AdapterFactory as l, clc as ln, HttpException as lt, assertAdapterSupports as m, HttpAdapterEnvironment as mn, MultipartParams as mt, XmlStreamAdapterFactory as n, normalizePath as nn, FrameworkError as nt, MultipartAdapterFactory as o, filterLogLevels as on, InternalServerErrorException as ot, adapterSupports as p, DefaultAdapterEnvironment as pn, Multipart as pt, ValidationErrorResponderToken as q, ConfigServiceToken as qn, isEmpty as qt, StreamAdapterFactory as r, stripEndSlash as rn, ConflictException as rt, HttpAdapterFactory as s, LOG_LEVELS as sn, ForbiddenException as st, NaviosFactory as t, isUndefined as tn, ProblemDetails as tt, AttributeFactory as u, yellow as un, UseGuards as ut, Reply as v, NaviosManagedMetadataKey as vn, HttpCode as vt, EndpointAdapterToken as w, getModuleCustomEntry as wn, ModuleLoaderService as wt, HttpAdapterToken as x, ModuleMetadata as xn, PluginContext as xt, NaviosOptionsToken as y, getManagedMetadata as yn, Header as yt, InstanceResolution as z, Controller as zn, LoggerOutput as zt };
+//# sourceMappingURL=index-r0i2txmg.d.cts.map