@noxfly/noxus 2.3.2 → 2.4.0

package/dist/child.js

@@ -1330,41 +1330,90 @@ Router = _ts_decorate([
 // src/DI/injector-explorer.ts
 var _InjectorExplorer = class _InjectorExplorer {
   /**
-   * Registers the class as injectable.
-   * When a class is instantiated, if it has dependencies and those dependencies
-   * are listed using this method, they will be injected into the class constructor.
+   * Enqueues a class for deferred registration.
+   * Called by the @Injectable decorator at import time.
+   *
+   * If {@link processPending} has already been called (i.e. after bootstrap),
+   * the class is registered immediately so that late dynamic imports
+   * (e.g. middlewares loaded after bootstrap) work correctly.
+   */
+  static enqueue(target, lifetime) {
+    if (_InjectorExplorer.processed) {
+      _InjectorExplorer.registerImmediate(target, lifetime);
+      return;
+    }
+    _InjectorExplorer.pending.push({
+      target,
+      lifetime
+    });
+  }
+  /**
+   * Processes all pending registrations in two phases:
+   * 1. Register all bindings (no instantiation) so every dependency is known.
+   * 2. Resolve singletons, register controllers and log module readiness.
+   *
+   * This two-phase approach makes the system resilient to import ordering:
+   * all bindings exist before any singleton is instantiated.
    */
-  static register(target, lifetime) {
-    if (RootInjector.bindings.has(target)) return RootInjector;
+  static processPending() {
+    const queue = _InjectorExplorer.pending;
+    for (const { target, lifetime } of queue) {
+      if (!RootInjector.bindings.has(target)) {
+        RootInjector.bindings.set(target, {
+          implementation: target,
+          lifetime
+        });
+      }
+    }
+    for (const { target, lifetime } of queue) {
+      _InjectorExplorer.processRegistration(target, lifetime);
+    }
+    queue.length = 0;
+    _InjectorExplorer.processed = true;
+  }
+  /**
+   * Registers a single class immediately (post-bootstrap path).
+   * Used for classes discovered via late dynamic imports.
+   */
+  static registerImmediate(target, lifetime) {
+    if (RootInjector.bindings.has(target)) {
+      return;
+    }
     RootInjector.bindings.set(target, {
       implementation: target,
       lifetime
     });
+    _InjectorExplorer.processRegistration(target, lifetime);
+  }
+  /**
+   * Performs phase-2 work for a single registration: resolve singletons,
+   * register controllers, and log module readiness.
+   */
+  static processRegistration(target, lifetime) {
     if (lifetime === "singleton") {
       RootInjector.resolve(target);
     }
     if (getModuleMetadata(target)) {
       Logger.log(`${target.name} dependencies initialized`);
-      return RootInjector;
+      return;
     }
     const controllerMeta = getControllerMetadata(target);
     if (controllerMeta) {
       const router = RootInjector.resolve(Router);
       router?.registerController(target);
-      return RootInjector;
+      return;
     }
-    const routeMeta = getRouteMetadata(target);
-    if (routeMeta) {
-      return RootInjector;
+    if (getRouteMetadata(target).length > 0) {
+      return;
     }
     if (getInjectableMetadata(target)) {
       Logger.log(`Registered ${target.name} as ${lifetime}`);
-      return RootInjector;
     }
-    return RootInjector;
   }
 };
 __name(_InjectorExplorer, "InjectorExplorer");
+__publicField(_InjectorExplorer, "pending", []);
+__publicField(_InjectorExplorer, "processed", false);
 var InjectorExplorer = _InjectorExplorer;
 
 // src/decorators/injectable.decorator.ts
@@ -1374,7 +1423,7 @@ function Injectable(lifetime = "scope") {
       throw new Error(`@Injectable can only be used on classes, not on ${typeof target}`);
     }
     defineInjectableMetadata(target, lifetime);
-    InjectorExplorer.register(target, lifetime);
+    InjectorExplorer.enqueue(target, lifetime);
   };
 }
 __name(Injectable, "Injectable");

package/dist/child.mjs

@@ -1261,41 +1261,90 @@ Router = _ts_decorate([
 // src/DI/injector-explorer.ts
 var _InjectorExplorer = class _InjectorExplorer {
   /**
-   * Registers the class as injectable.
-   * When a class is instantiated, if it has dependencies and those dependencies
-   * are listed using this method, they will be injected into the class constructor.
+   * Enqueues a class for deferred registration.
+   * Called by the @Injectable decorator at import time.
+   *
+   * If {@link processPending} has already been called (i.e. after bootstrap),
+   * the class is registered immediately so that late dynamic imports
+   * (e.g. middlewares loaded after bootstrap) work correctly.
+   */
+  static enqueue(target, lifetime) {
+    if (_InjectorExplorer.processed) {
+      _InjectorExplorer.registerImmediate(target, lifetime);
+      return;
+    }
+    _InjectorExplorer.pending.push({
+      target,
+      lifetime
+    });
+  }
+  /**
+   * Processes all pending registrations in two phases:
+   * 1. Register all bindings (no instantiation) so every dependency is known.
+   * 2. Resolve singletons, register controllers and log module readiness.
+   *
+   * This two-phase approach makes the system resilient to import ordering:
+   * all bindings exist before any singleton is instantiated.
    */
-  static register(target, lifetime) {
-    if (RootInjector.bindings.has(target)) return RootInjector;
+  static processPending() {
+    const queue = _InjectorExplorer.pending;
+    for (const { target, lifetime } of queue) {
+      if (!RootInjector.bindings.has(target)) {
+        RootInjector.bindings.set(target, {
+          implementation: target,
+          lifetime
+        });
+      }
+    }
+    for (const { target, lifetime } of queue) {
+      _InjectorExplorer.processRegistration(target, lifetime);
+    }
+    queue.length = 0;
+    _InjectorExplorer.processed = true;
+  }
+  /**
+   * Registers a single class immediately (post-bootstrap path).
+   * Used for classes discovered via late dynamic imports.
+   */
+  static registerImmediate(target, lifetime) {
+    if (RootInjector.bindings.has(target)) {
+      return;
+    }
     RootInjector.bindings.set(target, {
       implementation: target,
       lifetime
     });
+    _InjectorExplorer.processRegistration(target, lifetime);
+  }
+  /**
+   * Performs phase-2 work for a single registration: resolve singletons,
+   * register controllers, and log module readiness.
+   */
+  static processRegistration(target, lifetime) {
     if (lifetime === "singleton") {
       RootInjector.resolve(target);
     }
     if (getModuleMetadata(target)) {
       Logger.log(`${target.name} dependencies initialized`);
-      return RootInjector;
+      return;
     }
     const controllerMeta = getControllerMetadata(target);
     if (controllerMeta) {
       const router = RootInjector.resolve(Router);
       router?.registerController(target);
-      return RootInjector;
+      return;
     }
-    const routeMeta = getRouteMetadata(target);
-    if (routeMeta) {
-      return RootInjector;
+    if (getRouteMetadata(target).length > 0) {
+      return;
     }
     if (getInjectableMetadata(target)) {
       Logger.log(`Registered ${target.name} as ${lifetime}`);
-      return RootInjector;
     }
-    return RootInjector;
   }
 };
 __name(_InjectorExplorer, "InjectorExplorer");
+__publicField(_InjectorExplorer, "pending", []);
+__publicField(_InjectorExplorer, "processed", false);
 var InjectorExplorer = _InjectorExplorer;
 
 // src/decorators/injectable.decorator.ts
@@ -1305,7 +1354,7 @@ function Injectable(lifetime = "scope") {
       throw new Error(`@Injectable can only be used on classes, not on ${typeof target}`);
     }
     defineInjectableMetadata(target, lifetime);
-    InjectorExplorer.register(target, lifetime);
+    InjectorExplorer.enqueue(target, lifetime);
   };
 }
 __name(Injectable, "Injectable");

package/dist/main.d.mts

@@ -2,6 +2,7 @@ import { M as MaybeAsync, T as Type } from './app-injector-B3MvgV3k.mjs';
 export { A as AppInjector, F as ForwardRefFn, a as ForwardReference, I as IBinding, L as Lifetime, R as RootInjector, f as forwardRef, i as inject } from './app-injector-B3MvgV3k.mjs';
 import { R as Request, I as IResponse, a as IGuard, b as IPortRequester } from './index-DQBQQfMw.mjs';
 export { e as AtomicHttpMethod, A as Authorize, D as Delete, G as Get, H as HttpMethod, l as IBatchRequestItem, m as IBatchRequestPayload, n as IBatchResponsePayload, p as IRendererEventMessage, k as IRequest, d as IRouteMetadata, N as NoxRendererClient, i as Patch, P as Post, h as Put, o as RENDERER_EVENT_TYPE, j as ROUTE_METADATA_KEY, v as RendererClientOptions, s as RendererEventHandler, u as RendererEventRegistry, t as RendererEventSubscription, q as createRendererEventMessage, g as getGuardForController, c as getGuardForControllerAction, f as getRouteMetadata, r as isRendererEventMessage } from './index-DQBQQfMw.mjs';
+import { BrowserWindow } from 'electron/main';
 export { BadGatewayException, BadRequestException, ConflictException, ForbiddenException, GatewayTimeoutException, HttpVersionNotSupportedException, INJECTABLE_METADATA_KEY, INJECT_METADATA_KEY, Inject, Injectable, InsufficientStorageException, InternalServerException, LogLevel, Logger, LoopDetectedException, MethodNotAllowedException, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, PaymentRequiredException, RequestTimeoutException, ResponseException, ServiceUnavailableException, TooManyRequestsException, UnauthorizedException, UpgradeRequiredException, VariantAlsoNegotiatesException, getInjectableMetadata, hasInjectableMetadata } from './child.mjs';
 
 /**
@@ -185,7 +186,7 @@ declare class NoxSocket {
  */
 interface IApp {
     dispose(): Promise<void>;
-    onReady(): Promise<void>;
+    onReady(mainWindow?: BrowserWindow): Promise<void>;
     onActivated(): Promise<void>;
 }
 /**
@@ -196,6 +197,7 @@ declare class NoxApp {
     private readonly router;
     private readonly socket;
     private app;
+    private mainWindow;
     /**
      *
      */
@@ -231,6 +233,12 @@ declare class NoxApp {
      * This method is called when all windows are closed, and it cleans up the message channels
      */
     private onAllWindowsClosed;
+    /**
+     * Sets the main BrowserWindow that was created early by bootstrapApplication.
+     * This window will be passed to IApp.onReady when start() is called.
+     * @param window - The BrowserWindow created during bootstrap.
+     */
+    setMainWindow(window: BrowserWindow): void;
     /**
      * Configures the NoxApp instance with the provided application class.
      * This method allows you to set the application class that will handle lifecycle events.
@@ -247,21 +255,40 @@ declare class NoxApp {
     use(middleware: Type<IMiddleware>): NoxApp;
     /**
      * Should be called after the bootstrapApplication function is called.
+     * Passes the early-created BrowserWindow (if any) to the configured IApp service.
      * @returns NoxApp instance for method chaining.
      */
     start(): NoxApp;
 }
 
 
+/**
+ * Options for bootstrapping the Noxus application.
+ */
+interface BootstrapOptions {
+    /**
+     * If provided, Noxus creates a BrowserWindow immediately after Electron is ready,
+     * before any DI processing occurs. This window is passed to the configured
+     * IApp service via onReady(). It allows the user to see a window as fast as possible,
+     * even before the application is fully initialized.
+     */
+    window?: Electron.BrowserWindowConstructorOptions;
+}
 /**
  * Bootstraps the Noxus application.
  * This function initializes the application by creating an instance of NoxApp,
  * registering the root module, and starting the application.
+ *
+ * When {@link BootstrapOptions.window} is provided, a BrowserWindow is created
+ * immediately after Electron readiness — before DI resolution — so the user
+ * sees a window as quickly as possible.
+ *
  * @param rootModule - The root module of the application, decorated with @Module.
+ * @param options - Optional bootstrap configuration.
  * @return A promise that resolves to the NoxApp instance.
  * @throws Error if the root module is not decorated with @Module, or if the electron process could not start.
  */
-declare function bootstrapApplication(rootModule: Type<any>): Promise<NoxApp>;
+declare function bootstrapApplication(rootModule: Type<any>, options?: BootstrapOptions): Promise<NoxApp>;
 
 
 /**
@@ -321,4 +348,4 @@ interface NoxusPreloadOptions {
  */
 declare function exposeNoxusBridge(options?: NoxusPreloadOptions): NoxusPreloadAPI;
 
-export { CONTROLLER_METADATA_KEY, Controller, type ControllerAction, type IApp, type IControllerMetadata, IGuard, type IMiddleware, type IModuleMetadata, IPortRequester, IResponse, type IRouteDefinition, MODULE_METADATA_KEY, MaybeAsync, Module, type NextFunction, NoxApp, NoxSocket, type NoxusPreloadAPI, type NoxusPreloadOptions, Request, Router, Type, UseMiddlewares, bootstrapApplication, exposeNoxusBridge, getControllerMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata };
+export { type BootstrapOptions, CONTROLLER_METADATA_KEY, Controller, type ControllerAction, type IApp, type IControllerMetadata, IGuard, type IMiddleware, type IModuleMetadata, IPortRequester, IResponse, type IRouteDefinition, MODULE_METADATA_KEY, MaybeAsync, Module, type NextFunction, NoxApp, NoxSocket, type NoxusPreloadAPI, type NoxusPreloadOptions, Request, Router, Type, UseMiddlewares, bootstrapApplication, exposeNoxusBridge, getControllerMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata };

package/dist/main.d.ts

@@ -2,6 +2,7 @@ import { M as MaybeAsync, T as Type } from './app-injector-B3MvgV3k.js';
 export { A as AppInjector, F as ForwardRefFn, a as ForwardReference, I as IBinding, L as Lifetime, R as RootInjector, f as forwardRef, i as inject } from './app-injector-B3MvgV3k.js';
 import { R as Request, I as IResponse, a as IGuard, b as IPortRequester } from './index-BxWQVi6C.js';
 export { e as AtomicHttpMethod, A as Authorize, D as Delete, G as Get, H as HttpMethod, l as IBatchRequestItem, m as IBatchRequestPayload, n as IBatchResponsePayload, p as IRendererEventMessage, k as IRequest, d as IRouteMetadata, N as NoxRendererClient, i as Patch, P as Post, h as Put, o as RENDERER_EVENT_TYPE, j as ROUTE_METADATA_KEY, v as RendererClientOptions, s as RendererEventHandler, u as RendererEventRegistry, t as RendererEventSubscription, q as createRendererEventMessage, g as getGuardForController, c as getGuardForControllerAction, f as getRouteMetadata, r as isRendererEventMessage } from './index-BxWQVi6C.js';
+import { BrowserWindow } from 'electron/main';
 export { BadGatewayException, BadRequestException, ConflictException, ForbiddenException, GatewayTimeoutException, HttpVersionNotSupportedException, INJECTABLE_METADATA_KEY, INJECT_METADATA_KEY, Inject, Injectable, InsufficientStorageException, InternalServerException, LogLevel, Logger, LoopDetectedException, MethodNotAllowedException, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, PaymentRequiredException, RequestTimeoutException, ResponseException, ServiceUnavailableException, TooManyRequestsException, UnauthorizedException, UpgradeRequiredException, VariantAlsoNegotiatesException, getInjectableMetadata, hasInjectableMetadata } from './child.js';
 
 /**
@@ -185,7 +186,7 @@ declare class NoxSocket {
  */
 interface IApp {
     dispose(): Promise<void>;
-    onReady(): Promise<void>;
+    onReady(mainWindow?: BrowserWindow): Promise<void>;
     onActivated(): Promise<void>;
 }
 /**
@@ -196,6 +197,7 @@ declare class NoxApp {
     private readonly router;
     private readonly socket;
     private app;
+    private mainWindow;
     /**
      *
      */
@@ -231,6 +233,12 @@ declare class NoxApp {
      * This method is called when all windows are closed, and it cleans up the message channels
      */
     private onAllWindowsClosed;
+    /**
+     * Sets the main BrowserWindow that was created early by bootstrapApplication.
+     * This window will be passed to IApp.onReady when start() is called.
+     * @param window - The BrowserWindow created during bootstrap.
+     */
+    setMainWindow(window: BrowserWindow): void;
     /**
      * Configures the NoxApp instance with the provided application class.
      * This method allows you to set the application class that will handle lifecycle events.
@@ -247,21 +255,40 @@ declare class NoxApp {
     use(middleware: Type<IMiddleware>): NoxApp;
     /**
      * Should be called after the bootstrapApplication function is called.
+     * Passes the early-created BrowserWindow (if any) to the configured IApp service.
      * @returns NoxApp instance for method chaining.
      */
     start(): NoxApp;
 }
 
 
+/**
+ * Options for bootstrapping the Noxus application.
+ */
+interface BootstrapOptions {
+    /**
+     * If provided, Noxus creates a BrowserWindow immediately after Electron is ready,
+     * before any DI processing occurs. This window is passed to the configured
+     * IApp service via onReady(). It allows the user to see a window as fast as possible,
+     * even before the application is fully initialized.
+     */
+    window?: Electron.BrowserWindowConstructorOptions;
+}
 /**
  * Bootstraps the Noxus application.
  * This function initializes the application by creating an instance of NoxApp,
  * registering the root module, and starting the application.
+ *
+ * When {@link BootstrapOptions.window} is provided, a BrowserWindow is created
+ * immediately after Electron readiness — before DI resolution — so the user
+ * sees a window as quickly as possible.
+ *
  * @param rootModule - The root module of the application, decorated with @Module.
+ * @param options - Optional bootstrap configuration.
  * @return A promise that resolves to the NoxApp instance.
  * @throws Error if the root module is not decorated with @Module, or if the electron process could not start.
  */
-declare function bootstrapApplication(rootModule: Type<any>): Promise<NoxApp>;
+declare function bootstrapApplication(rootModule: Type<any>, options?: BootstrapOptions): Promise<NoxApp>;
 
 
 /**
@@ -321,4 +348,4 @@ interface NoxusPreloadOptions {
  */
 declare function exposeNoxusBridge(options?: NoxusPreloadOptions): NoxusPreloadAPI;
 
-export { CONTROLLER_METADATA_KEY, Controller, type ControllerAction, type IApp, type IControllerMetadata, IGuard, type IMiddleware, type IModuleMetadata, IPortRequester, IResponse, type IRouteDefinition, MODULE_METADATA_KEY, MaybeAsync, Module, type NextFunction, NoxApp, NoxSocket, type NoxusPreloadAPI, type NoxusPreloadOptions, Request, Router, Type, UseMiddlewares, bootstrapApplication, exposeNoxusBridge, getControllerMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata };
+export { type BootstrapOptions, CONTROLLER_METADATA_KEY, Controller, type ControllerAction, type IApp, type IControllerMetadata, IGuard, type IMiddleware, type IModuleMetadata, IPortRequester, IResponse, type IRouteDefinition, MODULE_METADATA_KEY, MaybeAsync, Module, type NextFunction, NoxApp, NoxSocket, type NoxusPreloadAPI, type NoxusPreloadOptions, Request, Router, Type, UseMiddlewares, bootstrapApplication, exposeNoxusBridge, getControllerMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata };

package/dist/main.js

@@ -825,41 +825,90 @@ var Logger;
 // src/DI/injector-explorer.ts
 var _InjectorExplorer = class _InjectorExplorer {
   /**
-   * Registers the class as injectable.
-   * When a class is instantiated, if it has dependencies and those dependencies
-   * are listed using this method, they will be injected into the class constructor.
+   * Enqueues a class for deferred registration.
+   * Called by the @Injectable decorator at import time.
+   *
+   * If {@link processPending} has already been called (i.e. after bootstrap),
+   * the class is registered immediately so that late dynamic imports
+   * (e.g. middlewares loaded after bootstrap) work correctly.
+   */
+  static enqueue(target, lifetime) {
+    if (_InjectorExplorer.processed) {
+      _InjectorExplorer.registerImmediate(target, lifetime);
+      return;
+    }
+    _InjectorExplorer.pending.push({
+      target,
+      lifetime
+    });
+  }
+  /**
+   * Processes all pending registrations in two phases:
+   * 1. Register all bindings (no instantiation) so every dependency is known.
+   * 2. Resolve singletons, register controllers and log module readiness.
+   *
+   * This two-phase approach makes the system resilient to import ordering:
+   * all bindings exist before any singleton is instantiated.
+   */
+  static processPending() {
+    const queue = _InjectorExplorer.pending;
+    for (const { target, lifetime } of queue) {
+      if (!RootInjector.bindings.has(target)) {
+        RootInjector.bindings.set(target, {
+          implementation: target,
+          lifetime
+        });
+      }
+    }
+    for (const { target, lifetime } of queue) {
+      _InjectorExplorer.processRegistration(target, lifetime);
+    }
+    queue.length = 0;
+    _InjectorExplorer.processed = true;
+  }
+  /**
+   * Registers a single class immediately (post-bootstrap path).
+   * Used for classes discovered via late dynamic imports.
    */
-  static register(target, lifetime) {
-    if (RootInjector.bindings.has(target)) return RootInjector;
+  static registerImmediate(target, lifetime) {
+    if (RootInjector.bindings.has(target)) {
+      return;
+    }
     RootInjector.bindings.set(target, {
       implementation: target,
       lifetime
     });
+    _InjectorExplorer.processRegistration(target, lifetime);
+  }
+  /**
+   * Performs phase-2 work for a single registration: resolve singletons,
+   * register controllers, and log module readiness.
+   */
+  static processRegistration(target, lifetime) {
     if (lifetime === "singleton") {
       RootInjector.resolve(target);
     }
     if (getModuleMetadata(target)) {
       Logger.log(`${target.name} dependencies initialized`);
-      return RootInjector;
+      return;
     }
     const controllerMeta = getControllerMetadata(target);
     if (controllerMeta) {
       const router = RootInjector.resolve(Router);
       router?.registerController(target);
-      return RootInjector;
+      return;
     }
-    const routeMeta = getRouteMetadata(target);
-    if (routeMeta) {
-      return RootInjector;
+    if (getRouteMetadata(target).length > 0) {
+      return;
     }
     if (getInjectableMetadata(target)) {
       Logger.log(`Registered ${target.name} as ${lifetime}`);
-      return RootInjector;
     }
-    return RootInjector;
   }
 };
 __name(_InjectorExplorer, "InjectorExplorer");
+__publicField(_InjectorExplorer, "pending", []);
+__publicField(_InjectorExplorer, "processed", false);
 var InjectorExplorer = _InjectorExplorer;
 
 // src/decorators/injectable.decorator.ts
@@ -869,7 +918,7 @@ function Injectable(lifetime = "scope") {
       throw new Error(`@Injectable can only be used on classes, not on ${typeof target}`);
     }
     defineInjectableMetadata(target, lifetime);
-    InjectorExplorer.register(target, lifetime);
+    InjectorExplorer.enqueue(target, lifetime);
   };
 }
 __name(Injectable, "Injectable");
@@ -1591,6 +1640,7 @@ var _NoxApp = class _NoxApp {
     __publicField(this, "router");
     __publicField(this, "socket");
     __publicField(this, "app");
+    __publicField(this, "mainWindow");
     /**
      *
      */
@@ -1697,6 +1747,14 @@ var _NoxApp = class _NoxApp {
     }
   }
   // ---
+  /**
+   * Sets the main BrowserWindow that was created early by bootstrapApplication.
+   * This window will be passed to IApp.onReady when start() is called.
+   * @param window - The BrowserWindow created during bootstrap.
+   */
+  setMainWindow(window2) {
+    this.mainWindow = window2;
+  }
   /**
    * Configures the NoxApp instance with the provided application class.
    * This method allows you to set the application class that will handle lifecycle events.
@@ -1719,10 +1777,11 @@ var _NoxApp = class _NoxApp {
   }
   /**
    * Should be called after the bootstrapApplication function is called.
+   * Passes the early-created BrowserWindow (if any) to the configured IApp service.
    * @returns NoxApp instance for method chaining.
    */
   start() {
-    this.app?.onReady();
+    this.app?.onReady(this.mainWindow);
     return this;
   }
 };
@@ -1739,12 +1798,20 @@ NoxApp = _ts_decorate3([
 
 // src/bootstrap.ts
 var import_main2 = require("electron/main");
-async function bootstrapApplication(rootModule) {
+async function bootstrapApplication(rootModule, options) {
   if (!getModuleMetadata(rootModule)) {
     throw new Error(`Root module must be decorated with @Module`);
   }
   await import_main2.app.whenReady();
+  let mainWindow;
+  if (options?.window) {
+    mainWindow = new import_main2.BrowserWindow(options.window);
+  }
+  InjectorExplorer.processPending();
   const noxApp = inject(NoxApp);
+  if (mainWindow) {
+    noxApp.setMainWindow(mainWindow);
+  }
   await noxApp.init();
   return noxApp;
 }

package/dist/main.mjs

@@ -726,41 +726,90 @@ var Logger;
 // src/DI/injector-explorer.ts
 var _InjectorExplorer = class _InjectorExplorer {
   /**
-   * Registers the class as injectable.
-   * When a class is instantiated, if it has dependencies and those dependencies
-   * are listed using this method, they will be injected into the class constructor.
+   * Enqueues a class for deferred registration.
+   * Called by the @Injectable decorator at import time.
+   *
+   * If {@link processPending} has already been called (i.e. after bootstrap),
+   * the class is registered immediately so that late dynamic imports
+   * (e.g. middlewares loaded after bootstrap) work correctly.
+   */
+  static enqueue(target, lifetime) {
+    if (_InjectorExplorer.processed) {
+      _InjectorExplorer.registerImmediate(target, lifetime);
+      return;
+    }
+    _InjectorExplorer.pending.push({
+      target,
+      lifetime
+    });
+  }
+  /**
+   * Processes all pending registrations in two phases:
+   * 1. Register all bindings (no instantiation) so every dependency is known.
+   * 2. Resolve singletons, register controllers and log module readiness.
+   *
+   * This two-phase approach makes the system resilient to import ordering:
+   * all bindings exist before any singleton is instantiated.
+   */
+  static processPending() {
+    const queue = _InjectorExplorer.pending;
+    for (const { target, lifetime } of queue) {
+      if (!RootInjector.bindings.has(target)) {
+        RootInjector.bindings.set(target, {
+          implementation: target,
+          lifetime
+        });
+      }
+    }
+    for (const { target, lifetime } of queue) {
+      _InjectorExplorer.processRegistration(target, lifetime);
+    }
+    queue.length = 0;
+    _InjectorExplorer.processed = true;
+  }
+  /**
+   * Registers a single class immediately (post-bootstrap path).
+   * Used for classes discovered via late dynamic imports.
    */
-  static register(target, lifetime) {
-    if (RootInjector.bindings.has(target)) return RootInjector;
+  static registerImmediate(target, lifetime) {
+    if (RootInjector.bindings.has(target)) {
+      return;
+    }
     RootInjector.bindings.set(target, {
       implementation: target,
       lifetime
     });
+    _InjectorExplorer.processRegistration(target, lifetime);
+  }
+  /**
+   * Performs phase-2 work for a single registration: resolve singletons,
+   * register controllers, and log module readiness.
+   */
+  static processRegistration(target, lifetime) {
     if (lifetime === "singleton") {
       RootInjector.resolve(target);
     }
     if (getModuleMetadata(target)) {
       Logger.log(`${target.name} dependencies initialized`);
-      return RootInjector;
+      return;
     }
     const controllerMeta = getControllerMetadata(target);
     if (controllerMeta) {
       const router = RootInjector.resolve(Router);
       router?.registerController(target);
-      return RootInjector;
+      return;
     }
-    const routeMeta = getRouteMetadata(target);
-    if (routeMeta) {
-      return RootInjector;
+    if (getRouteMetadata(target).length > 0) {
+      return;
     }
     if (getInjectableMetadata(target)) {
       Logger.log(`Registered ${target.name} as ${lifetime}`);
-      return RootInjector;
     }
-    return RootInjector;
   }
 };
 __name(_InjectorExplorer, "InjectorExplorer");
+__publicField(_InjectorExplorer, "pending", []);
+__publicField(_InjectorExplorer, "processed", false);
 var InjectorExplorer = _InjectorExplorer;
 
 // src/decorators/injectable.decorator.ts
@@ -770,7 +819,7 @@ function Injectable(lifetime = "scope") {
       throw new Error(`@Injectable can only be used on classes, not on ${typeof target}`);
     }
     defineInjectableMetadata(target, lifetime);
-    InjectorExplorer.register(target, lifetime);
+    InjectorExplorer.enqueue(target, lifetime);
   };
 }
 __name(Injectable, "Injectable");
@@ -1492,6 +1541,7 @@ var _NoxApp = class _NoxApp {
     __publicField(this, "router");
     __publicField(this, "socket");
     __publicField(this, "app");
+    __publicField(this, "mainWindow");
     /**
      *
      */
@@ -1598,6 +1648,14 @@ var _NoxApp = class _NoxApp {
     }
   }
   // ---
+  /**
+   * Sets the main BrowserWindow that was created early by bootstrapApplication.
+   * This window will be passed to IApp.onReady when start() is called.
+   * @param window - The BrowserWindow created during bootstrap.
+   */
+  setMainWindow(window2) {
+    this.mainWindow = window2;
+  }
   /**
    * Configures the NoxApp instance with the provided application class.
    * This method allows you to set the application class that will handle lifecycle events.
@@ -1620,10 +1678,11 @@ var _NoxApp = class _NoxApp {
   }
   /**
    * Should be called after the bootstrapApplication function is called.
+   * Passes the early-created BrowserWindow (if any) to the configured IApp service.
    * @returns NoxApp instance for method chaining.
    */
   start() {
-    this.app?.onReady();
+    this.app?.onReady(this.mainWindow);
     return this;
   }
 };
@@ -1639,13 +1698,21 @@ NoxApp = _ts_decorate3([
 ], NoxApp);
 
 // src/bootstrap.ts
-import { app as app2 } from "electron/main";
-async function bootstrapApplication(rootModule) {
+import { app as app2, BrowserWindow as BrowserWindow2 } from "electron/main";
+async function bootstrapApplication(rootModule, options) {
   if (!getModuleMetadata(rootModule)) {
     throw new Error(`Root module must be decorated with @Module`);
   }
   await app2.whenReady();
+  let mainWindow;
+  if (options?.window) {
+    mainWindow = new BrowserWindow2(options.window);
+  }
+  InjectorExplorer.processPending();
   const noxApp = inject(NoxApp);
+  if (mainWindow) {
+    noxApp.setMainWindow(mainWindow);
+  }
   await noxApp.init();
   return noxApp;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@noxfly/noxus",
-    "version": "2.3.2",
+    "version": "2.4.0",
     "main": "dist/main.js",
     "module": "dist/main.mjs",
     "types": "dist/main.d.ts",

package/src/DI/injector-explorer.ts

@@ -13,31 +13,96 @@ import { Router } from "src/router";
 import { Logger } from "src/utils/logger";
 import { Type } from "src/utils/types";
 
+interface PendingRegistration {
+    target: Type<unknown>;
+    lifetime: Lifetime;
+}
+
 /**
  * InjectorExplorer is a utility class that explores the dependency injection system at the startup.
+ * It collects decorated classes during the import phase and defers their actual registration
+ * and resolution to when {@link processPending} is called by bootstrapApplication.
  */
 export class InjectorExplorer {
+    private static readonly pending: PendingRegistration[] = [];
+    private static processed = false;
+
     /**
-     * Registers the class as injectable.
-     * When a class is instantiated, if it has dependencies and those dependencies
-     * are listed using this method, they will be injected into the class constructor.
+     * Enqueues a class for deferred registration.
+     * Called by the @Injectable decorator at import time.
+     *
+     * If {@link processPending} has already been called (i.e. after bootstrap),
+     * the class is registered immediately so that late dynamic imports
+     * (e.g. middlewares loaded after bootstrap) work correctly.
      */
-    public static register(target: Type<unknown>, lifetime: Lifetime): typeof RootInjector {
-        if(RootInjector.bindings.has(target)) // already registered
-            return RootInjector;
+    public static enqueue(target: Type<unknown>, lifetime: Lifetime): void {
+        if(InjectorExplorer.processed) {
+            InjectorExplorer.registerImmediate(target, lifetime);
+            return;
+        }
+
+        InjectorExplorer.pending.push({ target, lifetime });
+    }
+
+    /**
+     * Processes all pending registrations in two phases:
+     * 1. Register all bindings (no instantiation) so every dependency is known.
+     * 2. Resolve singletons, register controllers and log module readiness.
+     *
+     * This two-phase approach makes the system resilient to import ordering:
+     * all bindings exist before any singleton is instantiated.
+     */
+    public static processPending(): void {
+        const queue = InjectorExplorer.pending;
+
+        // Phase 1: register all bindings without instantiation
+        for(const { target, lifetime } of queue) {
+            if(!RootInjector.bindings.has(target)) {
+                RootInjector.bindings.set(target, {
+                    implementation: target,
+                    lifetime
+                });
+            }
+        }
+
+        // Phase 2: resolve singletons, register controllers, log modules
+        for(const { target, lifetime } of queue) {
+            InjectorExplorer.processRegistration(target, lifetime);
+        }
+
+        queue.length = 0;
+        InjectorExplorer.processed = true;
+    }
+
+    /**
+     * Registers a single class immediately (post-bootstrap path).
+     * Used for classes discovered via late dynamic imports.
+     */
+    private static registerImmediate(target: Type<unknown>, lifetime: Lifetime): void {
+        if(RootInjector.bindings.has(target)) {
+            return;
+        }
 
         RootInjector.bindings.set(target, {
             implementation: target,
             lifetime
         });
 
+        InjectorExplorer.processRegistration(target, lifetime);
+    }
+
+    /**
+     * Performs phase-2 work for a single registration: resolve singletons,
+     * register controllers, and log module readiness.
+     */
+    private static processRegistration(target: Type<unknown>, lifetime: Lifetime): void {
         if(lifetime === 'singleton') {
             RootInjector.resolve(target);
         }
 
         if(getModuleMetadata(target)) {
             Logger.log(`${target.name} dependencies initialized`);
-            return RootInjector;
+            return;
         }
 
         const controllerMeta = getControllerMetadata(target);
@@ -45,20 +110,15 @@ export class InjectorExplorer {
         if(controllerMeta) {
             const router = RootInjector.resolve(Router);
             router?.registerController(target);
-            return RootInjector;
+            return;
         }
 
-        const routeMeta = getRouteMetadata(target);
-
-        if(routeMeta) {
-            return RootInjector;
+        if(getRouteMetadata(target).length > 0) {
+            return;
         }
 
         if(getInjectableMetadata(target)) {
             Logger.log(`Registered ${target.name} as ${lifetime}`);
-            return RootInjector;
         }
-
-        return RootInjector;
     }
 }

package/src/app.ts

@@ -21,7 +21,7 @@ import { Type } from "src/utils/types";
  */
 export interface IApp {
     dispose(): Promise<void>;
-    onReady(): Promise<void>;
+    onReady(mainWindow?: BrowserWindow): Promise<void>;
     onActivated(): Promise<void>;
 }
 
@@ -32,6 +32,7 @@ export interface IApp {
 @Injectable('singleton')
 export class NoxApp {
     private app: IApp | undefined;
+    private mainWindow: BrowserWindow | undefined;
 
     /**
      *
@@ -163,6 +164,15 @@ export class NoxApp {
 
     // ---
 
+    /**
+     * Sets the main BrowserWindow that was created early by bootstrapApplication.
+     * This window will be passed to IApp.onReady when start() is called.
+     * @param window - The BrowserWindow created during bootstrap.
+     */
+    public setMainWindow(window: BrowserWindow): void {
+        this.mainWindow = window;
+    }
+
     /**
      * Configures the NoxApp instance with the provided application class.
      * This method allows you to set the application class that will handle lifecycle events.
@@ -187,10 +197,11 @@ export class NoxApp {
 
     /**
      * Should be called after the bootstrapApplication function is called.
+     * Passes the early-created BrowserWindow (if any) to the configured IApp service.
      * @returns NoxApp instance for method chaining.
      */
     public start(): NoxApp {
-        this.app?.onReady();
+        this.app?.onReady(this.mainWindow);
         return this;
     }
 }

package/src/bootstrap.ts

@@ -4,29 +4,64 @@
  * @author NoxFly
  */
 
-import { app } from "electron/main";
+import { app, BrowserWindow } from "electron/main";
 import { NoxApp } from "src/app";
 import { getModuleMetadata } from "src/decorators/module.decorator";
 import { inject } from "src/DI/app-injector";
+import { InjectorExplorer } from "src/DI/injector-explorer";
 import { Type } from "src/utils/types";
 
+/**
+ * Options for bootstrapping the Noxus application.
+ */
+export interface BootstrapOptions {
+    /**
+     * If provided, Noxus creates a BrowserWindow immediately after Electron is ready,
+     * before any DI processing occurs. This window is passed to the configured
+     * IApp service via onReady(). It allows the user to see a window as fast as possible,
+     * even before the application is fully initialized.
+     */
+    window?: Electron.BrowserWindowConstructorOptions;
+}
+
 /**
  * Bootstraps the Noxus application.
  * This function initializes the application by creating an instance of NoxApp,
  * registering the root module, and starting the application.
+ *
+ * When {@link BootstrapOptions.window} is provided, a BrowserWindow is created
+ * immediately after Electron readiness — before DI resolution — so the user
+ * sees a window as quickly as possible.
+ *
  * @param rootModule - The root module of the application, decorated with @Module.
+ * @param options - Optional bootstrap configuration.
  * @return A promise that resolves to the NoxApp instance.
  * @throws Error if the root module is not decorated with @Module, or if the electron process could not start.
  */
-export async function bootstrapApplication(rootModule: Type<any>): Promise<NoxApp> {
+export async function bootstrapApplication(rootModule: Type<any>, options?: BootstrapOptions): Promise<NoxApp> {
     if(!getModuleMetadata(rootModule)) {
         throw new Error(`Root module must be decorated with @Module`);
     }
 
     await app.whenReady();
 
+    // Create window immediately after Electron is ready, before DI processing.
+    // This gets pixels on screen as fast as possible.
+    let mainWindow: BrowserWindow | undefined;
+
+    if(options?.window) {
+        mainWindow = new BrowserWindow(options.window);
+    }
+
+    // Process all deferred injectable registrations (two-phase: bindings then resolution)
+    InjectorExplorer.processPending();
+
     const noxApp = inject(NoxApp);
 
+    if(mainWindow) {
+        noxApp.setMainWindow(mainWindow);
+    }
+
     await noxApp.init();
 
     return noxApp;

package/src/decorators/injectable.decorator.ts

@@ -23,6 +23,6 @@ export function Injectable(lifetime: Lifetime = "scope"): ClassDecorator {
             throw new Error(`@Injectable can only be used on classes, not on ${typeof target}`);
         }
         defineInjectableMetadata(target, lifetime);
-        InjectorExplorer.register(target as unknown as Type<any>, lifetime);
+        InjectorExplorer.enqueue(target as unknown as Type<any>, lifetime);
     };
 }