@noxfly/noxus 3.0.0-dev.3 → 3.0.0-dev.4

package/dist/renderer.mjs

@@ -4,131 +4,155 @@
  * @author NoxFly
  */
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 
 // src/utils/forward-ref.ts
-var _ForwardReference = class _ForwardReference {
-  constructor(forwardRefFn) {
-    this.forwardRefFn = forwardRefFn;
+var _ForwardReference, ForwardReference;
+var init_forward_ref = __esm({
+  "src/utils/forward-ref.ts"() {
+    "use strict";
+    _ForwardReference = class _ForwardReference {
+      constructor(forwardRefFn) {
+        this.forwardRefFn = forwardRefFn;
+      }
+    };
+    __name(_ForwardReference, "ForwardReference");
+    ForwardReference = _ForwardReference;
   }
-};
-__name(_ForwardReference, "ForwardReference");
-var ForwardReference = _ForwardReference;
+});
 
 // src/DI/token.ts
-var _Token = class _Token {
-  constructor(target) {
-    this.target = target;
-    this.description = typeof target === "string" ? target : target.name;
-  }
-  toString() {
-    return `Token(${this.description})`;
+var _Token, Token;
+var init_token = __esm({
+  "src/DI/token.ts"() {
+    "use strict";
+    _Token = class _Token {
+      constructor(target) {
+        this.target = target;
+        this.description = typeof target === "string" ? target : target.name;
+      }
+      toString() {
+        return `Token(${this.description})`;
+      }
+    };
+    __name(_Token, "Token");
+    Token = _Token;
   }
-};
-__name(_Token, "Token");
-var Token = _Token;
+});
 
 // src/DI/app-injector.ts
 function keyOf(k) {
   return k;
 }
-__name(keyOf, "keyOf");
-var _AppInjector = class _AppInjector {
-  constructor(name = null) {
-    this.name = name;
-    this.bindings = /* @__PURE__ */ new Map();
-    this.singletons = /* @__PURE__ */ new Map();
-    this.scoped = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Creates a child scope for per-request lifetime resolution.
-   */
-  createScope() {
-    const scope = new _AppInjector();
-    scope.bindings = this.bindings;
-    scope.singletons = this.singletons;
-    return scope;
-  }
-  /**
-   * Registers a binding explicitly.
-   */
-  register(key, implementation, lifetime, deps = []) {
-    const k = keyOf(key);
-    if (!this.bindings.has(k)) {
-      this.bindings.set(k, { lifetime, implementation, deps });
-    }
-  }
-  /**
-   * Resolves a dependency by token or class reference.
-   */
-  resolve(target) {
-    if (target instanceof ForwardReference) {
-      return this._resolveForwardRef(target);
-    }
-    const k = keyOf(target);
-    if (this.singletons.has(k)) {
-      return this.singletons.get(k);
-    }
-    const binding = this.bindings.get(k);
-    if (!binding) {
-      const name = target instanceof Token ? target.description : target.name ?? "unknown";
-      throw new Error(
-        `[Noxus DI] No binding found for "${name}".
-Did you forget to declare it in @Injectable({ deps }) or in bootstrapApplication({ singletons })?`
-      );
-    }
-    switch (binding.lifetime) {
-      case "transient":
-        return this._instantiate(binding);
-      case "scope": {
-        if (this.scoped.has(k)) return this.scoped.get(k);
-        const inst = this._instantiate(binding);
-        this.scoped.set(k, inst);
-        return inst;
+var _AppInjector, AppInjector, RootInjector;
+var init_app_injector = __esm({
+  "src/DI/app-injector.ts"() {
+    "use strict";
+    init_forward_ref();
+    init_token();
+    __name(keyOf, "keyOf");
+    _AppInjector = class _AppInjector {
+      constructor(name = null) {
+        this.name = name;
+        this.bindings = /* @__PURE__ */ new Map();
+        this.singletons = /* @__PURE__ */ new Map();
+        this.scoped = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Creates a child scope for per-request lifetime resolution.
+       */
+      createScope() {
+        const scope = new _AppInjector();
+        scope.bindings = this.bindings;
+        scope.singletons = this.singletons;
+        return scope;
       }
-      case "singleton": {
-        if (this.singletons.has(k)) return this.singletons.get(k);
-        const inst = this._instantiate(binding);
-        this.singletons.set(k, inst);
-        if (binding.instance === void 0) {
-          binding.instance = inst;
+      /**
+       * Registers a binding explicitly.
+       */
+      register(key, implementation, lifetime, deps = []) {
+        const k = keyOf(key);
+        if (!this.bindings.has(k)) {
+          this.bindings.set(k, { lifetime, implementation, deps });
         }
-        return inst;
       }
-    }
-  }
-  // -------------------------------------------------------------------------
-  _resolveForwardRef(ref) {
-    return new Proxy({}, {
-      get: /* @__PURE__ */ __name((_obj, prop, receiver) => {
-        const realType = ref.forwardRefFn();
-        const instance = this.resolve(realType);
-        const value = Reflect.get(instance, prop, receiver);
-        return typeof value === "function" ? value.bind(instance) : value;
-      }, "get"),
-      set: /* @__PURE__ */ __name((_obj, prop, value, receiver) => {
-        const realType = ref.forwardRefFn();
-        const instance = this.resolve(realType);
-        return Reflect.set(instance, prop, value, receiver);
-      }, "set"),
-      getPrototypeOf: /* @__PURE__ */ __name(() => {
-        const realType = ref.forwardRefFn();
-        return realType.prototype;
-      }, "getPrototypeOf")
-    });
-  }
-  _instantiate(binding) {
-    const resolvedDeps = binding.deps.map((dep) => this.resolve(dep));
-    return new binding.implementation(...resolvedDeps);
+      /**
+       * Resolves a dependency by token or class reference.
+       */
+      resolve(target) {
+        if (target instanceof ForwardReference) {
+          return this._resolveForwardRef(target);
+        }
+        const k = keyOf(target);
+        if (this.singletons.has(k)) {
+          return this.singletons.get(k);
+        }
+        const binding = this.bindings.get(k);
+        if (!binding) {
+          const name = target instanceof Token ? target.description : target.name ?? "unknown";
+          throw new Error(
+            `[Noxus DI] No binding found for "${name}".
+Did you forget to declare it in @Injectable({ deps }) or in bootstrapApplication({ singletons })?`
+          );
+        }
+        switch (binding.lifetime) {
+          case "transient":
+            return this._instantiate(binding);
+          case "scope": {
+            if (this.scoped.has(k)) return this.scoped.get(k);
+            const inst = this._instantiate(binding);
+            this.scoped.set(k, inst);
+            return inst;
+          }
+          case "singleton": {
+            if (this.singletons.has(k)) return this.singletons.get(k);
+            const inst = this._instantiate(binding);
+            this.singletons.set(k, inst);
+            if (binding.instance === void 0) {
+              binding.instance = inst;
+            }
+            return inst;
+          }
+        }
+      }
+      // -------------------------------------------------------------------------
+      _resolveForwardRef(ref) {
+        let resolved;
+        return new Proxy({}, {
+          get: /* @__PURE__ */ __name((_obj, prop, receiver) => {
+            resolved ?? (resolved = this.resolve(ref.forwardRefFn()));
+            const value = Reflect.get(resolved, prop, receiver);
+            return typeof value === "function" ? value.bind(resolved) : value;
+          }, "get"),
+          set: /* @__PURE__ */ __name((_obj, prop, value, receiver) => {
+            resolved ?? (resolved = this.resolve(ref.forwardRefFn()));
+            return Reflect.set(resolved, prop, value, receiver);
+          }, "set"),
+          getPrototypeOf: /* @__PURE__ */ __name(() => {
+            resolved ?? (resolved = this.resolve(ref.forwardRefFn()));
+            return Object.getPrototypeOf(resolved);
+          }, "getPrototypeOf")
+        });
+      }
+      _instantiate(binding) {
+        const resolvedDeps = binding.deps.map((dep) => this.resolve(dep));
+        return new binding.implementation(...resolvedDeps);
+      }
+    };
+    __name(_AppInjector, "AppInjector");
+    AppInjector = _AppInjector;
+    RootInjector = new AppInjector("root");
   }
-};
-__name(_AppInjector, "AppInjector");
-var AppInjector = _AppInjector;
-var RootInjector = new AppInjector("root");
+});
 
 // src/internal/request.ts
+init_app_injector();
 var _Request = class _Request {
-  constructor(event, senderId, id, method, path, body) {
+  constructor(event, senderId, id, method, path, body, query) {
     this.event = event;
     this.senderId = senderId;
     this.id = id;
@@ -138,6 +162,7 @@ var _Request = class _Request {
     this.context = RootInjector.createScope();
     this.params = {};
     this.path = path.replace(/^\/|\/$/g, "");
+    this.query = query ?? {};
   }
 };
 __name(_Request, "Request");
@@ -340,6 +365,9 @@ var _NoxRendererClient = class _NoxRendererClient {
         console.error(`[Noxus] No pending handler found for request ${response.requestId}.`);
         return;
       }
+      if (pending.timer !== void 0) {
+        clearTimeout(pending.timer);
+      }
       this.pendingRequests.delete(response.requestId);
       this.onRequestCompleted(pending, response);
       if (response.status >= 400) {
@@ -353,6 +381,8 @@ var _NoxRendererClient = class _NoxRendererClient {
     this.bridge = resolvedBridge ?? null;
     this.initMessageType = options.initMessageType ?? DEFAULT_INIT_EVENT;
     this.generateRequestId = options.generateRequestId ?? defaultRequestId;
+    this.requestTimeout = options.requestTimeout ?? 1e4;
+    this.enableLogging = options.enableLogging ?? true;
   }
   async setup() {
     if (this.isReady) {
@@ -380,6 +410,11 @@ var _NoxRendererClient = class _NoxRendererClient {
     this.socketPort = void 0;
     this.senderId = void 0;
     this.isReady = false;
+    for (const pending of this.pendingRequests.values()) {
+      if (pending.timer !== void 0) {
+        clearTimeout(pending.timer);
+      }
+    }
     this.pendingRequests.clear();
   }
   async request(request) {
@@ -404,6 +439,12 @@ var _NoxRendererClient = class _NoxRendererClient {
         request: message,
         submittedAt: Date.now()
       };
+      if (this.requestTimeout > 0) {
+        pending.timer = setTimeout(() => {
+          this.pendingRequests.delete(message.requestId);
+          reject(this.createErrorResponse(message.requestId, `Request timed out after ${this.requestTimeout}ms`));
+        }, this.requestTimeout);
+      }
       this.pendingRequests.set(message.requestId, pending);
       this.requestPort.postMessage(message);
     });
@@ -421,6 +462,9 @@ var _NoxRendererClient = class _NoxRendererClient {
     return this.senderId;
   }
   onRequestCompleted(pending, response) {
+    if (!this.enableLogging) {
+      return;
+    }
     if (typeof console.groupCollapsed === "function") {
       console.groupCollapsed(`${response.status} ${pending.request.method} /${pending.request.path}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@noxfly/noxus",
-    "version": "3.0.0-dev.3",
+    "version": "3.0.0-dev.4",
     "main": "dist/main.js",
     "module": "dist/main.mjs",
     "types": "dist/main.d.ts",

package/src/DI/app-injector.ts

@@ -122,21 +122,20 @@ export class AppInjector {
     // -------------------------------------------------------------------------
 
     private _resolveForwardRef<T>(ref: ForwardReference<T>): T {
+        let resolved: T | undefined;
         return new Proxy({} as object, {
             get: (_obj, prop, receiver) => {
-                const realType = ref.forwardRefFn();
-                const instance = this.resolve(realType) as Record<string | symbol, unknown>;
-                const value = Reflect.get(instance, prop, receiver);
-                return typeof value === 'function' ? (value as Function).bind(instance) : value;
+                resolved ??= this.resolve(ref.forwardRefFn()) as T;
+                const value = Reflect.get(resolved as object, prop, receiver);
+                return typeof value === 'function' ? (value as Function).bind(resolved) : value;
             },
             set: (_obj, prop, value, receiver) => {
-                const realType = ref.forwardRefFn();
-                const instance = this.resolve(realType) as object;
-                return Reflect.set(instance, prop, value, receiver);
+                resolved ??= this.resolve(ref.forwardRefFn()) as T;
+                return Reflect.set(resolved as object, prop, value, receiver);
             },
             getPrototypeOf: () => {
-                const realType = ref.forwardRefFn();
-                return (realType as unknown as { prototype: object }).prototype;
+                resolved ??= this.resolve(ref.forwardRefFn()) as T;
+                return Object.getPrototypeOf(resolved);
             },
         }) as T;
     }
@@ -152,6 +151,20 @@ export class AppInjector {
  */
 export const RootInjector = new AppInjector('root');
 
+/**
+ * Resets the root injector to a clean state.
+ * **Intended for testing only** — clears all bindings, singletons, and scoped instances
+ * so that each test can start from a fresh DI container without restarting the process.
+ */
+export function resetRootInjector(): void {
+    RootInjector.bindings.clear();
+    RootInjector.singletons.clear();
+    RootInjector.scoped.clear();
+    // Lazy import to avoid circular dependency (InjectorExplorer → app-injector → InjectorExplorer)
+    const { InjectorExplorer } = require('./injector-explorer') as typeof import('./injector-explorer');
+    InjectorExplorer.reset();
+}
+
 /**
  * Convenience function: resolve a token from the root injector.
  */

package/src/DI/injector-explorer.ts

@@ -8,7 +8,8 @@ import { Lifetime, RootInjector } from './app-injector';
 import { TokenKey } from './token';
 import { Type } from '../utils/types';
 import { Logger } from '../utils/logger';
-import { Guard, Middleware } from "src/main";
+import { Guard } from '../decorators/guards.decorator';
+import { Middleware } from '../decorators/middleware.decorator';
 
 export interface PendingRegistration {
     key: TokenKey;
@@ -19,6 +20,17 @@ export interface PendingRegistration {
     pathPrefix?: string;
 }
 
+/**
+ * Callback invoked for each controller registration discovered during flush.
+ * Decouples InjectorExplorer from the Router to avoid circular imports.
+ */
+export type ControllerRegistrar = (
+    controllerClass: Type<unknown>,
+    pathPrefix: string,
+    routeGuards: Guard[],
+    routeMiddlewares: Middleware[],
+) => void;
+
 /**
  * InjectorExplorer accumulates registrations emitted by decorators
  * at import time, then flushes them in two phases (bind → resolve)
@@ -31,11 +43,21 @@ export class InjectorExplorer {
     private static readonly pending: PendingRegistration[] = [];
     private static processed = false;
     private static accumulating = false;
+    private static loadingLock: Promise<void> = Promise.resolve();
+    private static controllerRegistrar: ControllerRegistrar | null = null;
 
     // -------------------------------------------------------------------------
     // Public API
     // -------------------------------------------------------------------------
 
+    /**
+     * Sets the callback used to register controllers.
+     * Must be called once before processPending (typically by bootstrapApplication).
+     */
+    public static setControllerRegistrar(registrar: ControllerRegistrar): void {
+        InjectorExplorer.controllerRegistrar = registrar;
+    }
+
     public static enqueue(reg: PendingRegistration): void {
         if (InjectorExplorer.processed && !InjectorExplorer.accumulating) {
             InjectorExplorer._registerImmediate(reg);
@@ -66,23 +88,47 @@ export class InjectorExplorer {
     /**
      * Exits accumulation mode and flushes queued registrations
      * with the same two-phase guarantee as processPending.
+     * Serialised through a lock to prevent concurrent lazy loads from corrupting the queue.
      */
     public static flushAccumulated(
         routeGuards: Guard[] = [],
         routeMiddlewares: Middleware[] = [],
         pathPrefix = '',
-    ): void {
-        InjectorExplorer.accumulating = false;
-        const queue = [...InjectorExplorer.pending];
-        InjectorExplorer.pending.length = 0;
-        InjectorExplorer._phaseOne(queue);
+    ): Promise<void> {
+        InjectorExplorer.loadingLock = InjectorExplorer.loadingLock.then(() => {
+            InjectorExplorer.accumulating = false;
+            const queue = [...InjectorExplorer.pending];
+            InjectorExplorer.pending.length = 0;
+            InjectorExplorer._phaseOne(queue);
+
+            // Stamp the path prefix on controller registrations
+            for (const reg of queue) {
+                if (reg.isController) reg.pathPrefix = pathPrefix;
+            }
 
-        // Stamp the path prefix on controller registrations
-        for (const reg of queue) {
-            if (reg.isController) reg.pathPrefix = pathPrefix;
-        }
+            InjectorExplorer._phaseTwo(queue, undefined, routeGuards, routeMiddlewares);
+        });
 
-        InjectorExplorer._phaseTwo(queue, undefined, routeGuards, routeMiddlewares);
+        return InjectorExplorer.loadingLock;
+    }
+
+    /**
+     * Returns a Promise that resolves once all pending flushAccumulated calls
+     * have completed. Useful for awaiting lazy-load serialisation.
+     */
+    public static waitForFlush(): Promise<void> {
+        return InjectorExplorer.loadingLock;
+    }
+
+    /**
+     * Resets the explorer state. Intended for tests only.
+     */
+    public static reset(): void {
+        InjectorExplorer.pending.length = 0;
+        InjectorExplorer.processed = false;
+        InjectorExplorer.accumulating = false;
+        InjectorExplorer.loadingLock = Promise.resolve();
+        InjectorExplorer.controllerRegistrar = null;
     }
 
     // -------------------------------------------------------------------------
@@ -96,13 +142,22 @@ export class InjectorExplorer {
         }
     }
 
-    /** Phase 2: resolve singletons and register controllers in the router. */
+    /** Phase 2: validate deps, resolve singletons and register controllers via the registrar callback. */
     private static _phaseTwo(
         queue: PendingRegistration[],
         overrides?: Map<TokenKey, unknown>,
         routeGuards: Guard[] = [],
         routeMiddlewares: Middleware[] = [],
     ): void {
+        // Early dependency validation: warn about deps that have no binding
+        for (const reg of queue) {
+            for (const dep of reg.deps) {
+                if (!RootInjector.bindings.has(dep as any) && !RootInjector.singletons.has(dep as any)) {
+                    Logger.warn(`[Noxus DI] "${reg.implementation.name}" declares dep "${(dep as any).name ?? dep}" which has no binding`);
+                }
+            }
+        }
+
         for (const reg of queue) {
             // Apply value overrides (e.g. singleton instances provided via bootstrapApplication config)
             if (overrides?.has(reg.key)) {
@@ -117,10 +172,15 @@ export class InjectorExplorer {
             }
 
             if (reg.isController) {
-                // Lazily import Router to avoid circular dependency at module load time
-                const { Router } = require('../internal/router') as { Router: { prototype: { registerController(t: Type<unknown>): void } } };
-                const router = RootInjector.resolve(Router as any) as { registerController(t: Type<unknown>, pathPrefix: string, routeGuards: Guard[], routeMiddlewares: Middleware[]): void };
-                router.registerController(reg.implementation, reg.pathPrefix ?? '', routeGuards, routeMiddlewares);
+                if (!InjectorExplorer.controllerRegistrar) {
+                    throw new Error('[Noxus DI] No controller registrar set. Call InjectorExplorer.setControllerRegistrar() before processing.');
+                }
+                InjectorExplorer.controllerRegistrar(
+                    reg.implementation,
+                    reg.pathPrefix ?? '',
+                    routeGuards,
+                    routeMiddlewares,
+                );
             } else if (reg.lifetime !== 'singleton') {
                 Logger.log(`Registered ${reg.implementation.name} as ${reg.lifetime}`);
             }
@@ -134,10 +194,8 @@ export class InjectorExplorer {
             RootInjector.resolve(reg.key);
         }
 
-        if (reg.isController) {
-            const { Router } = require('../internal/router') as { Router: { prototype: { registerController(t: Type<unknown>): void } } };
-            const router = RootInjector.resolve(Router as any) as { registerController(t: Type<unknown>): void };
-            router.registerController(reg.implementation);
+        if (reg.isController && InjectorExplorer.controllerRegistrar) {
+            InjectorExplorer.controllerRegistrar(reg.implementation, '', [], []);
         }
     }
 }

package/src/internal/app.ts

@@ -5,7 +5,7 @@
  */
 
 import { app, BrowserWindow, ipcMain, MessageChannelMain } from 'electron/main';
-import { Guard } from "src/main";
+import { Guard } from "../decorators/guards.decorator";
 import { Injectable } from '../decorators/injectable.decorator';
 import { Middleware } from '../decorators/middleware.decorator';
 import { inject } from '../DI/app-injector';
@@ -49,9 +49,11 @@ export interface IApp {
 export class NoxApp {
     private appService: IApp | undefined;
 
-    private readonly router = inject(Router);
-    private readonly socket = inject(NoxSocket);
-    public readonly windowManager = inject(WindowManager);
+    constructor(
+        private readonly router: Router,
+        private readonly socket: NoxSocket,
+        public readonly windowManager: WindowManager,
+    ) {}
 
     // -------------------------------------------------------------------------
     // Initialisation
@@ -99,7 +101,7 @@ export class NoxApp {
     public async load(importFns: Array<() => Promise<unknown>>): Promise<this> {
         InjectorExplorer.beginAccumulate();
         await Promise.all(importFns.map((fn) => fn()));
-        InjectorExplorer.flushAccumulated();
+        await InjectorExplorer.flushAccumulated();
         return this;
     }
 
@@ -134,7 +136,7 @@ export class NoxApp {
     // -------------------------------------------------------------------------
 
     private readonly onRendererMessage = async (event: Electron.MessageEvent): Promise<void> => {
-        const { senderId, requestId, path, method, body }: import('./request').IRequest = event.data;
+        const { senderId, requestId, path, method, body, query }: import('./request').IRequest = event.data;
         const channels = this.socket.get(senderId);
 
         if (!channels) {
@@ -143,7 +145,7 @@ export class NoxApp {
         }
 
         try {
-            const request = new Request(event, senderId, requestId, method, path, body);
+            const request = new Request(event, senderId, requestId, method, path, body, query);
             const response = await this.router.handle(request);
             channels.request.port1.postMessage(response);
         }

package/src/internal/bootstrap.ts

@@ -8,8 +8,10 @@ import { app } from 'electron/main';
 import { inject, RootInjector } from '../DI/app-injector';
 import { InjectorExplorer } from '../DI/injector-explorer';
 import { TokenKey } from '../DI/token';
+import { Logger } from '../utils/logger';
 import { NoxApp } from './app';
 import { RouteDefinition } from "./routes";
+import { Router } from './router';
 
 /**
  * A singleton value override: provides an already-constructed instance
@@ -68,6 +70,16 @@ export interface BootstrapConfig {
      * ]
      */
     eagerLoad?: Array<() => Promise<unknown>>;
+
+    /**
+     * Controls framework log verbosity.
+     * - `'debug'`: all messages (default during development).
+     * - `'info'`: info, warn, error, critical only.
+     * - `'none'`: completely silent — no framework logs.
+     *
+     * You can also pass an array of specific log levels to enable.
+     */
+    logLevel?: 'debug' | 'info' | 'none' | import('../utils/logger').LogLevel[];
 }
 
 /**
@@ -76,6 +88,17 @@ export interface BootstrapConfig {
 export async function bootstrapApplication(config: BootstrapConfig = {}): Promise<NoxApp> {
     await app.whenReady();
 
+    // Apply log level configuration
+    if (config.logLevel !== undefined) {
+        if (config.logLevel === 'none') {
+            Logger.setLogLevel([]);
+        } else if (Array.isArray(config.logLevel)) {
+            Logger.setLogLevel(config.logLevel);
+        } else {
+            Logger.setLogLevel(config.logLevel);
+        }
+    }
+
     // Build override map for the DI flush phase
     const overrides = new Map<TokenKey, unknown>();
 
@@ -86,6 +109,13 @@ export async function bootstrapApplication(config: BootstrapConfig = {}): Promis
     }
 
     // Flush all classes enqueued by decorators at import time (two-phase)
+    // Wire the controller registrar so InjectorExplorer can register controllers
+    // without directly importing Router (avoids circular dependency).
+    InjectorExplorer.setControllerRegistrar((controllerClass, pathPrefix, routeGuards, routeMiddlewares) => {
+        const router = inject(Router);
+        router.registerController(controllerClass, pathPrefix, routeGuards, routeMiddlewares);
+    });
+
     InjectorExplorer.processPending(overrides);
 
     // Resolve core framework singletons
@@ -94,7 +124,9 @@ export async function bootstrapApplication(config: BootstrapConfig = {}): Promis
     // Register routes from the routing table
     if (config.routes?.length) {
         for (const route of config.routes) {
-            noxApp.lazy(route.path, route.load, route.guards, route.middlewares);
+            if (route.load) {
+                noxApp.lazy(route.path, route.load, route.guards, route.middlewares);
+            }
         }
     }