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

package/dist/main.js

@@ -86,116 +86,6 @@ var init_token = __esm({
   }
 });
 
-// src/DI/app-injector.ts
-function keyOf(k) {
-  return k;
-}
-function inject(t) {
-  return RootInjector.resolve(t);
-}
-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;
-      }
-      /**
-       * 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;
-          }
-          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) {
-        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);
-      }
-    };
-    __name(_AppInjector, "AppInjector");
-    AppInjector = _AppInjector;
-    RootInjector = new AppInjector("root");
-    __name(inject, "inject");
-  }
-});
-
 // src/utils/logger.ts
 function getPrettyTimestamp() {
   const now = /* @__PURE__ */ new Date();
@@ -444,6 +334,10 @@ var init_logger = __esm({
 });
 
 // src/DI/injector-explorer.ts
+var injector_explorer_exports = {};
+__export(injector_explorer_exports, {
+  InjectorExplorer: () => InjectorExplorer
+});
 var _InjectorExplorer, InjectorExplorer;
 var init_injector_explorer = __esm({
   "src/DI/injector-explorer.ts"() {
@@ -454,6 +348,13 @@ var init_injector_explorer = __esm({
       // -------------------------------------------------------------------------
       // Public API
       // -------------------------------------------------------------------------
+      /**
+       * Sets the callback used to register controllers.
+       * Must be called once before processPending (typically by bootstrapApplication).
+       */
+      static setControllerRegistrar(registrar) {
+        _InjectorExplorer.controllerRegistrar = registrar;
+      }
       static enqueue(reg) {
         if (_InjectorExplorer.processed && !_InjectorExplorer.accumulating) {
           _InjectorExplorer._registerImmediate(reg);
@@ -479,16 +380,37 @@ var init_injector_explorer = __esm({
       /**
        * 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.
        */
       static flushAccumulated(routeGuards = [], routeMiddlewares = [], pathPrefix = "") {
-        _InjectorExplorer.accumulating = false;
-        const queue = [..._InjectorExplorer.pending];
+        _InjectorExplorer.loadingLock = _InjectorExplorer.loadingLock.then(() => {
+          _InjectorExplorer.accumulating = false;
+          const queue = [..._InjectorExplorer.pending];
+          _InjectorExplorer.pending.length = 0;
+          _InjectorExplorer._phaseOne(queue);
+          for (const reg of queue) {
+            if (reg.isController) reg.pathPrefix = pathPrefix;
+          }
+          _InjectorExplorer._phaseTwo(queue, void 0, routeGuards, routeMiddlewares);
+        });
+        return _InjectorExplorer.loadingLock;
+      }
+      /**
+       * Returns a Promise that resolves once all pending flushAccumulated calls
+       * have completed. Useful for awaiting lazy-load serialisation.
+       */
+      static waitForFlush() {
+        return _InjectorExplorer.loadingLock;
+      }
+      /**
+       * Resets the explorer state. Intended for tests only.
+       */
+      static reset() {
         _InjectorExplorer.pending.length = 0;
-        _InjectorExplorer._phaseOne(queue);
-        for (const reg of queue) {
-          if (reg.isController) reg.pathPrefix = pathPrefix;
-        }
-        _InjectorExplorer._phaseTwo(queue, void 0, routeGuards, routeMiddlewares);
+        _InjectorExplorer.processed = false;
+        _InjectorExplorer.accumulating = false;
+        _InjectorExplorer.loadingLock = Promise.resolve();
+        _InjectorExplorer.controllerRegistrar = null;
       }
       // -------------------------------------------------------------------------
       // Private helpers
@@ -499,8 +421,15 @@ var init_injector_explorer = __esm({
           RootInjector.register(reg.key, reg.implementation, reg.lifetime, reg.deps);
         }
       }
-      /** Phase 2: resolve singletons and register controllers in the router. */
+      /** Phase 2: validate deps, resolve singletons and register controllers via the registrar callback. */
       static _phaseTwo(queue, overrides, routeGuards = [], routeMiddlewares = []) {
+        for (const reg of queue) {
+          for (const dep of reg.deps) {
+            if (!RootInjector.bindings.has(dep) && !RootInjector.singletons.has(dep)) {
+              Logger.warn(`[Noxus DI] "${reg.implementation.name}" declares dep "${dep.name ?? dep}" which has no binding`);
+            }
+          }
+        }
         for (const reg of queue) {
           if (overrides?.has(reg.key)) {
             const override = overrides.get(reg.key);
@@ -512,9 +441,15 @@ var init_injector_explorer = __esm({
             RootInjector.resolve(reg.key);
           }
           if (reg.isController) {
-            const { Router: Router2 } = (init_router(), __toCommonJS(router_exports));
-            const router = RootInjector.resolve(Router2);
-            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}`);
           }
@@ -525,10 +460,8 @@ var init_injector_explorer = __esm({
         if (reg.lifetime === "singleton") {
           RootInjector.resolve(reg.key);
         }
-        if (reg.isController) {
-          const { Router: Router2 } = (init_router(), __toCommonJS(router_exports));
-          const router = RootInjector.resolve(Router2);
-          router.registerController(reg.implementation);
+        if (reg.isController && _InjectorExplorer.controllerRegistrar) {
+          _InjectorExplorer.controllerRegistrar(reg.implementation, "", [], []);
         }
       }
     };
@@ -536,11 +469,193 @@ var init_injector_explorer = __esm({
     _InjectorExplorer.pending = [];
     _InjectorExplorer.processed = false;
     _InjectorExplorer.accumulating = false;
+    _InjectorExplorer.loadingLock = Promise.resolve();
+    _InjectorExplorer.controllerRegistrar = null;
     InjectorExplorer = _InjectorExplorer;
   }
 });
 
+// src/DI/app-injector.ts
+function keyOf(k) {
+  return k;
+}
+function resetRootInjector() {
+  RootInjector.bindings.clear();
+  RootInjector.singletons.clear();
+  RootInjector.scoped.clear();
+  const { InjectorExplorer: InjectorExplorer2 } = (init_injector_explorer(), __toCommonJS(injector_explorer_exports));
+  InjectorExplorer2.reset();
+}
+function inject(t) {
+  return RootInjector.resolve(t);
+}
+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;
+      }
+      /**
+       * 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;
+          }
+          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(resetRootInjector, "resetRootInjector");
+    __name(inject, "inject");
+  }
+});
+
+// src/main.ts
+var main_exports = {};
+__export(main_exports, {
+  AppInjector: () => AppInjector,
+  BadGatewayException: () => BadGatewayException,
+  BadRequestException: () => BadRequestException,
+  ConflictException: () => ConflictException,
+  Controller: () => Controller,
+  Delete: () => Delete,
+  ForbiddenException: () => ForbiddenException,
+  ForwardReference: () => ForwardReference,
+  GatewayTimeoutException: () => GatewayTimeoutException,
+  Get: () => Get,
+  HttpVersionNotSupportedException: () => HttpVersionNotSupportedException,
+  Injectable: () => Injectable,
+  InsufficientStorageException: () => InsufficientStorageException,
+  InternalServerException: () => InternalServerException,
+  Logger: () => Logger,
+  LoopDetectedException: () => LoopDetectedException,
+  MethodNotAllowedException: () => MethodNotAllowedException,
+  NetworkAuthenticationRequiredException: () => NetworkAuthenticationRequiredException,
+  NetworkConnectTimeoutException: () => NetworkConnectTimeoutException,
+  NotAcceptableException: () => NotAcceptableException,
+  NotExtendedException: () => NotExtendedException,
+  NotFoundException: () => NotFoundException,
+  NotImplementedException: () => NotImplementedException,
+  NoxApp: () => NoxApp,
+  NoxSocket: () => NoxSocket,
+  Patch: () => Patch,
+  PaymentRequiredException: () => PaymentRequiredException,
+  Post: () => Post,
+  Put: () => Put,
+  RENDERER_EVENT_TYPE: () => RENDERER_EVENT_TYPE,
+  Request: () => Request,
+  RequestTimeoutException: () => RequestTimeoutException,
+  ResponseException: () => ResponseException,
+  RootInjector: () => RootInjector,
+  Router: () => Router,
+  ServiceUnavailableException: () => ServiceUnavailableException,
+  Token: () => Token,
+  TooManyRequestsException: () => TooManyRequestsException,
+  UnauthorizedException: () => UnauthorizedException,
+  UpgradeRequiredException: () => UpgradeRequiredException,
+  VariantAlsoNegotiatesException: () => VariantAlsoNegotiatesException,
+  WindowManager: () => WindowManager,
+  bootstrapApplication: () => bootstrapApplication,
+  createRendererEventMessage: () => createRendererEventMessage,
+  defineRoutes: () => defineRoutes,
+  forwardRef: () => forwardRef,
+  getControllerMetadata: () => getControllerMetadata,
+  getRouteMetadata: () => getRouteMetadata,
+  inject: () => inject,
+  isAtomicHttpMethod: () => isAtomicHttpMethod,
+  isRendererEventMessage: () => isRendererEventMessage,
+  resetRootInjector: () => resetRootInjector,
+  token: () => token
+});
+module.exports = __toCommonJS(main_exports);
+init_app_injector();
+init_token();
+
 // src/decorators/controller.decorator.ts
+init_injector_explorer();
+var controllerMetaMap = /* @__PURE__ */ new WeakMap();
 function Controller(options = {}) {
   return (target) => {
     const meta = {
@@ -556,21 +671,15 @@ function Controller(options = {}) {
     });
   };
 }
+__name(Controller, "Controller");
 function getControllerMetadata(target) {
   return controllerMetaMap.get(target);
 }
-var controllerMetaMap;
-var init_controller_decorator = __esm({
-  "src/decorators/controller.decorator.ts"() {
-    "use strict";
-    init_injector_explorer();
-    controllerMetaMap = /* @__PURE__ */ new WeakMap();
-    __name(Controller, "Controller");
-    __name(getControllerMetadata, "getControllerMetadata");
-  }
-});
+__name(getControllerMetadata, "getControllerMetadata");
 
 // src/decorators/injectable.decorator.ts
+init_injector_explorer();
+init_token();
 function Injectable(options = {}) {
   const { lifetime = "scope", deps = [] } = options;
   return (target) => {
@@ -587,19 +696,15 @@ function Injectable(options = {}) {
     });
   };
 }
-var init_injectable_decorator = __esm({
-  "src/decorators/injectable.decorator.ts"() {
-    "use strict";
-    init_injector_explorer();
-    init_token();
-    __name(Injectable, "Injectable");
-  }
-});
+__name(Injectable, "Injectable");
 
 // src/decorators/method.decorator.ts
+var ATOMIC_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
 function isAtomicHttpMethod(m) {
   return typeof m === "string" && ATOMIC_METHODS.has(m);
 }
+__name(isAtomicHttpMethod, "isAtomicHttpMethod");
+var routeMetaMap = /* @__PURE__ */ new WeakMap();
 function createRouteDecorator(verb) {
   return (path2, options = {}) => {
     return (target, propertyKey) => {
@@ -616,399 +721,416 @@ function createRouteDecorator(verb) {
     };
   };
 }
+__name(createRouteDecorator, "createRouteDecorator");
 function getRouteMetadata(target) {
   return routeMetaMap.get(target) ?? [];
 }
-var ATOMIC_METHODS, routeMetaMap, Get, Post, Put, Patch, Delete;
-var init_method_decorator = __esm({
-  "src/decorators/method.decorator.ts"() {
-    "use strict";
-    ATOMIC_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-    __name(isAtomicHttpMethod, "isAtomicHttpMethod");
-    routeMetaMap = /* @__PURE__ */ new WeakMap();
-    __name(createRouteDecorator, "createRouteDecorator");
-    __name(getRouteMetadata, "getRouteMetadata");
-    Get = createRouteDecorator("GET");
-    Post = createRouteDecorator("POST");
-    Put = createRouteDecorator("PUT");
-    Patch = createRouteDecorator("PATCH");
-    Delete = createRouteDecorator("DELETE");
-  }
-});
+__name(getRouteMetadata, "getRouteMetadata");
+var Get = createRouteDecorator("GET");
+var Post = createRouteDecorator("POST");
+var Put = createRouteDecorator("PUT");
+var Patch = createRouteDecorator("PATCH");
+var Delete = createRouteDecorator("DELETE");
+
+// src/internal/router.ts
+init_injector_explorer();
+init_logger();
 
 // src/utils/radix-tree.ts
-var _RadixNode, RadixNode, _RadixTree, RadixTree;
-var init_radix_tree = __esm({
-  "src/utils/radix-tree.ts"() {
-    "use strict";
-    _RadixNode = class _RadixNode {
-      /**
-       * Creates a new RadixNode.
-       * @param segment - The segment of the path this node represents.
-       */
-      constructor(segment) {
-        this.children = [];
-        this.segment = segment;
-        this.isParam = segment.startsWith(":");
-        if (this.isParam) {
-          this.paramName = segment.slice(1);
-        }
-      }
-      /**
-       * Matches a child node against a given segment.
-       * This method checks if the segment matches any of the children nodes.
-       * @param segment - The segment to match against the children of this node.
-       * @returns A child node that matches the segment, or undefined if no match is found.
-       */
-      matchChild(segment) {
-        for (const child of this.children) {
-          if (child.isParam || segment.startsWith(child.segment))
-            return child;
-        }
-        return void 0;
-      }
-      /**
-       * Finds a child node that matches the segment exactly.
-       * This method checks if there is a child node that matches the segment exactly.
-       * @param segment - The segment to find an exact match for among the children of this node.
-       * @returns A child node that matches the segment exactly, or undefined if no match is found.
-       */
-      findExactChild(segment) {
-        return this.children.find((c) => c.segment === segment);
-      }
-      /**
-       * Adds a child node to this node's children.
-       * This method adds a new child node to the list of children for this node.
-       * @param node - The child node to add to this node's children.
-       */
-      addChild(node) {
-        this.children.push(node);
-      }
-    };
-    __name(_RadixNode, "RadixNode");
-    RadixNode = _RadixNode;
-    _RadixTree = class _RadixTree {
-      constructor() {
-        this.root = new RadixNode("");
+var _RadixNode = class _RadixNode {
+  /**
+   * Creates a new RadixNode.
+   * @param segment - The segment of the path this node represents.
+   */
+  constructor(segment) {
+    this.children = [];
+    this.segment = segment;
+    this.isParam = segment.startsWith(":");
+    if (this.isParam) {
+      this.paramName = segment.slice(1);
+    }
+  }
+  /**
+   * Matches a child node against a given segment.
+   * This method checks if the segment matches any of the children nodes.
+   * @param segment - The segment to match against the children of this node.
+   * @returns A child node that matches the segment, or undefined if no match is found.
+   */
+  matchChild(segment) {
+    for (const child of this.children) {
+      if (child.isParam || segment.startsWith(child.segment))
+        return child;
+    }
+    return void 0;
+  }
+  /**
+   * Finds a child node that matches the segment exactly.
+   * This method checks if there is a child node that matches the segment exactly.
+   * @param segment - The segment to find an exact match for among the children of this node.
+   * @returns A child node that matches the segment exactly, or undefined if no match is found.
+   */
+  findExactChild(segment) {
+    return this.children.find((c) => c.segment === segment);
+  }
+  /**
+   * Adds a child node to this node's children.
+   * This method adds a new child node to the list of children for this node.
+   * @param node - The child node to add to this node's children.
+   */
+  addChild(node) {
+    this.children.push(node);
+  }
+};
+__name(_RadixNode, "RadixNode");
+var RadixNode = _RadixNode;
+var _RadixTree = class _RadixTree {
+  constructor() {
+    this.root = new RadixNode("");
+  }
+  /**
+   * Inserts a path and its associated value into the Radix Tree.
+   * This method normalizes the path and inserts it into the tree, associating it with
+   * @param path - The path to insert into the tree.
+   * @param value - The value to associate with the path.
+   */
+  insert(path2, value) {
+    const segments = this.normalize(path2);
+    this.insertRecursive(this.root, segments, value);
+  }
+  /**
+   * Recursively inserts a path into the Radix Tree.
+   * This method traverses the tree and inserts the segments of the path, creating new nodes
+   * @param node - The node to start inserting from.
+   * @param segments - The segments of the path to insert.
+   * @param value - The value to associate with the path.
+   */
+  insertRecursive(node, segments, value) {
+    if (segments.length === 0) {
+      node.value = value;
+      return;
+    }
+    const segment = segments[0] ?? "";
+    let child = node.children.find(
+      (c) => c.isParam === segment.startsWith(":") && (c.isParam || c.segment === segment)
+    );
+    if (!child) {
+      child = new RadixNode(segment);
+      node.addChild(child);
+    }
+    this.insertRecursive(child, segments.slice(1), value);
+  }
+  /**
+   * Searches for a path in the Radix Tree.
+   * This method normalizes the path and searches for it in the tree, returning the node
+   * @param path - The path to search for in the Radix Tree.
+   * @returns An ISearchResult containing the node and parameters if a match is found, otherwise undefined.
+   */
+  search(path2) {
+    const segments = this.normalize(path2);
+    return this.searchRecursive(this.root, segments, {});
+  }
+  collectValues(node, values = []) {
+    if (!node) {
+      node = this.root;
+    }
+    if (node.value !== void 0) {
+      values.push(node.value);
+    }
+    for (const child of node.children) {
+      this.collectValues(child, values);
+    }
+    return values;
+  }
+  /**
+   * Recursively searches for a path in the Radix Tree.
+   * This method traverses the tree and searches for the segments of the path, collecting parameters
+   * @param node - The node to start searching from.
+   * @param segments - The segments of the path to search for.
+   * @param params - The parameters collected during the search.
+   * @returns An ISearchResult containing the node and parameters if a match is found, otherwise undefined.
+   */
+  searchRecursive(node, segments, params) {
+    if (segments.length === 0) {
+      if (node.value !== void 0) {
+        return {
+          node,
+          params
+        };
       }
-      /**
-       * Inserts a path and its associated value into the Radix Tree.
-       * This method normalizes the path and inserts it into the tree, associating it with
-       * @param path - The path to insert into the tree.
-       * @param value - The value to associate with the path.
-       */
-      insert(path2, value) {
-        const segments = this.normalize(path2);
-        this.insertRecursive(this.root, segments, value);
+      return void 0;
+    }
+    const [segment, ...rest] = segments;
+    const staticChildren = [];
+    const paramChildren = [];
+    for (const child of node.children) {
+      if (child.isParam) {
+        paramChildren.push(child);
+      } else if (segment === child.segment) {
+        staticChildren.push(child);
       }
-      /**
-       * Recursively inserts a path into the Radix Tree.
-       * This method traverses the tree and inserts the segments of the path, creating new nodes
-       * @param node - The node to start inserting from.
-       * @param segments - The segments of the path to insert.
-       * @param value - The value to associate with the path.
-       */
-      insertRecursive(node, segments, value) {
-        if (segments.length === 0) {
-          node.value = value;
-          return;
-        }
-        const segment = segments[0] ?? "";
-        let child = node.children.find(
-          (c) => c.isParam === segment.startsWith(":") && (c.isParam || c.segment === segment)
-        );
-        if (!child) {
-          child = new RadixNode(segment);
-          node.addChild(child);
+    }
+    for (const child of staticChildren) {
+      if (rest.length === 0) {
+        if (child.value !== void 0 || child.children.length > 0) {
+          return { node: child, params };
         }
-        this.insertRecursive(child, segments.slice(1), value);
       }
-      /**
-       * Searches for a path in the Radix Tree.
-       * This method normalizes the path and searches for it in the tree, returning the node
-       * @param path - The path to search for in the Radix Tree.
-       * @returns An ISearchResult containing the node and parameters if a match is found, otherwise undefined.
-       */
-      search(path2) {
-        const segments = this.normalize(path2);
-        return this.searchRecursive(this.root, segments, {});
-      }
-      /**
-       * Recursively searches for a path in the Radix Tree.
-       * This method traverses the tree and searches for the segments of the path, collecting parameters
-       * @param node - The node to start searching from.
-       * @param segments - The segments of the path to search for.
-       * @param params - The parameters collected during the search.
-       * @returns An ISearchResult containing the node and parameters if a match is found, otherwise undefined.
-       */
-      searchRecursive(node, segments, params) {
-        if (segments.length === 0) {
-          if (node.value !== void 0) {
-            return {
-              node,
-              params
-            };
-          }
-          return void 0;
-        }
-        const [segment, ...rest] = segments;
-        for (const child of node.children) {
-          if (child.isParam) {
-            const paramName = child.paramName;
-            const childParams = {
-              ...params,
-              [paramName]: segment ?? ""
-            };
-            if (rest.length === 0) {
-              return {
-                node: child,
-                params: childParams
-              };
-            }
-            const result = this.searchRecursive(child, rest, childParams);
-            if (result)
-              return result;
-          } else if (segment === child.segment) {
-            if (rest.length === 0) {
-              return {
-                node: child,
-                params
-              };
-            }
-            const result = this.searchRecursive(child, rest, params);
-            if (result)
-              return result;
-          }
+      const result = this.searchRecursive(child, rest, params);
+      if (result) return result;
+    }
+    for (const child of paramChildren) {
+      const paramName = child.paramName;
+      const childParams = {
+        ...params,
+        [paramName]: segment ?? ""
+      };
+      if (rest.length === 0) {
+        if (child.value !== void 0 || child.children.length > 0) {
+          return { node: child, params: childParams };
         }
-        return void 0;
-      }
-      /**
-       * Normalizes a path into an array of segments.
-       * This method removes leading and trailing slashes, splits the path by slashes, and
-       * @param path - The path to normalize.
-       * @returns An array of normalized path segments.
-       */
-      normalize(path2) {
-        const segments = path2.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
-        return ["", ...segments];
       }
-    };
-    __name(_RadixTree, "RadixTree");
-    RadixTree = _RadixTree;
+      const result = this.searchRecursive(child, rest, childParams);
+      if (result) return result;
+    }
+    return void 0;
+  }
+  /**
+   * Normalizes a path into an array of segments.
+   * This method removes leading and trailing slashes, splits the path by slashes, and
+   * @param path - The path to normalize.
+   * @returns An array of normalized path segments.
+   */
+  normalize(path2) {
+    const segments = path2.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+    return ["", ...segments];
+  }
+};
+__name(_RadixTree, "RadixTree");
+var RadixTree = _RadixTree;
+
+// src/internal/exceptions.ts
+var _ResponseException = class _ResponseException extends Error {
+  constructor(statusOrMessage, message) {
+    let statusCode;
+    if (typeof statusOrMessage === "number") {
+      statusCode = statusOrMessage;
+    } else if (typeof statusOrMessage === "string") {
+      message = statusOrMessage;
+    }
+    super(message ?? "");
+    this.status = 0;
+    if (statusCode !== void 0) {
+      this.status = statusCode;
+    }
+    this.name = this.constructor.name.replace(/([A-Z])/g, " $1");
+  }
+};
+__name(_ResponseException, "ResponseException");
+var ResponseException = _ResponseException;
+var _BadRequestException = class _BadRequestException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 400;
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var _UnauthorizedException = class _UnauthorizedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 401;
+  }
+};
+__name(_UnauthorizedException, "UnauthorizedException");
+var UnauthorizedException = _UnauthorizedException;
+var _PaymentRequiredException = class _PaymentRequiredException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 402;
+  }
+};
+__name(_PaymentRequiredException, "PaymentRequiredException");
+var PaymentRequiredException = _PaymentRequiredException;
+var _ForbiddenException = class _ForbiddenException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 403;
+  }
+};
+__name(_ForbiddenException, "ForbiddenException");
+var ForbiddenException = _ForbiddenException;
+var _NotFoundException = class _NotFoundException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 404;
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var _MethodNotAllowedException = class _MethodNotAllowedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 405;
+  }
+};
+__name(_MethodNotAllowedException, "MethodNotAllowedException");
+var MethodNotAllowedException = _MethodNotAllowedException;
+var _NotAcceptableException = class _NotAcceptableException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 406;
+  }
+};
+__name(_NotAcceptableException, "NotAcceptableException");
+var NotAcceptableException = _NotAcceptableException;
+var _RequestTimeoutException = class _RequestTimeoutException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 408;
+  }
+};
+__name(_RequestTimeoutException, "RequestTimeoutException");
+var RequestTimeoutException = _RequestTimeoutException;
+var _ConflictException = class _ConflictException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 409;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _UpgradeRequiredException = class _UpgradeRequiredException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 426;
+  }
+};
+__name(_UpgradeRequiredException, "UpgradeRequiredException");
+var UpgradeRequiredException = _UpgradeRequiredException;
+var _TooManyRequestsException = class _TooManyRequestsException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 429;
+  }
+};
+__name(_TooManyRequestsException, "TooManyRequestsException");
+var TooManyRequestsException = _TooManyRequestsException;
+var _InternalServerException = class _InternalServerException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 500;
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _NotImplementedException = class _NotImplementedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 501;
+  }
+};
+__name(_NotImplementedException, "NotImplementedException");
+var NotImplementedException = _NotImplementedException;
+var _BadGatewayException = class _BadGatewayException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 502;
+  }
+};
+__name(_BadGatewayException, "BadGatewayException");
+var BadGatewayException = _BadGatewayException;
+var _ServiceUnavailableException = class _ServiceUnavailableException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 503;
+  }
+};
+__name(_ServiceUnavailableException, "ServiceUnavailableException");
+var ServiceUnavailableException = _ServiceUnavailableException;
+var _GatewayTimeoutException = class _GatewayTimeoutException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 504;
+  }
+};
+__name(_GatewayTimeoutException, "GatewayTimeoutException");
+var GatewayTimeoutException = _GatewayTimeoutException;
+var _HttpVersionNotSupportedException = class _HttpVersionNotSupportedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 505;
+  }
+};
+__name(_HttpVersionNotSupportedException, "HttpVersionNotSupportedException");
+var HttpVersionNotSupportedException = _HttpVersionNotSupportedException;
+var _VariantAlsoNegotiatesException = class _VariantAlsoNegotiatesException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 506;
+  }
+};
+__name(_VariantAlsoNegotiatesException, "VariantAlsoNegotiatesException");
+var VariantAlsoNegotiatesException = _VariantAlsoNegotiatesException;
+var _InsufficientStorageException = class _InsufficientStorageException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 507;
+  }
+};
+__name(_InsufficientStorageException, "InsufficientStorageException");
+var InsufficientStorageException = _InsufficientStorageException;
+var _LoopDetectedException = class _LoopDetectedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 508;
+  }
+};
+__name(_LoopDetectedException, "LoopDetectedException");
+var LoopDetectedException = _LoopDetectedException;
+var _NotExtendedException = class _NotExtendedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 510;
   }
-});
-
-// src/internal/exceptions.ts
-var _ResponseException, ResponseException, _BadRequestException, BadRequestException, _UnauthorizedException, UnauthorizedException, _PaymentRequiredException, PaymentRequiredException, _ForbiddenException, ForbiddenException, _NotFoundException, NotFoundException, _MethodNotAllowedException, MethodNotAllowedException, _NotAcceptableException, NotAcceptableException, _RequestTimeoutException, RequestTimeoutException, _ConflictException, ConflictException, _UpgradeRequiredException, UpgradeRequiredException, _TooManyRequestsException, TooManyRequestsException, _InternalServerException, InternalServerException, _NotImplementedException, NotImplementedException, _BadGatewayException, BadGatewayException, _ServiceUnavailableException, ServiceUnavailableException, _GatewayTimeoutException, GatewayTimeoutException, _HttpVersionNotSupportedException, HttpVersionNotSupportedException, _VariantAlsoNegotiatesException, VariantAlsoNegotiatesException, _InsufficientStorageException, InsufficientStorageException, _LoopDetectedException, LoopDetectedException, _NotExtendedException, NotExtendedException, _NetworkAuthenticationRequiredException, NetworkAuthenticationRequiredException, _NetworkConnectTimeoutException, NetworkConnectTimeoutException;
-var init_exceptions = __esm({
-  "src/internal/exceptions.ts"() {
-    "use strict";
-    _ResponseException = class _ResponseException extends Error {
-      constructor(statusOrMessage, message) {
-        let statusCode;
-        if (typeof statusOrMessage === "number") {
-          statusCode = statusOrMessage;
-        } else if (typeof statusOrMessage === "string") {
-          message = statusOrMessage;
-        }
-        super(message ?? "");
-        this.status = 0;
-        if (statusCode !== void 0) {
-          this.status = statusCode;
-        }
-        this.name = this.constructor.name.replace(/([A-Z])/g, " $1");
-      }
-    };
-    __name(_ResponseException, "ResponseException");
-    ResponseException = _ResponseException;
-    _BadRequestException = class _BadRequestException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 400;
-      }
-    };
-    __name(_BadRequestException, "BadRequestException");
-    BadRequestException = _BadRequestException;
-    _UnauthorizedException = class _UnauthorizedException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 401;
-      }
-    };
-    __name(_UnauthorizedException, "UnauthorizedException");
-    UnauthorizedException = _UnauthorizedException;
-    _PaymentRequiredException = class _PaymentRequiredException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 402;
-      }
-    };
-    __name(_PaymentRequiredException, "PaymentRequiredException");
-    PaymentRequiredException = _PaymentRequiredException;
-    _ForbiddenException = class _ForbiddenException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 403;
-      }
-    };
-    __name(_ForbiddenException, "ForbiddenException");
-    ForbiddenException = _ForbiddenException;
-    _NotFoundException = class _NotFoundException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 404;
-      }
-    };
-    __name(_NotFoundException, "NotFoundException");
-    NotFoundException = _NotFoundException;
-    _MethodNotAllowedException = class _MethodNotAllowedException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 405;
-      }
-    };
-    __name(_MethodNotAllowedException, "MethodNotAllowedException");
-    MethodNotAllowedException = _MethodNotAllowedException;
-    _NotAcceptableException = class _NotAcceptableException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 406;
-      }
-    };
-    __name(_NotAcceptableException, "NotAcceptableException");
-    NotAcceptableException = _NotAcceptableException;
-    _RequestTimeoutException = class _RequestTimeoutException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 408;
-      }
-    };
-    __name(_RequestTimeoutException, "RequestTimeoutException");
-    RequestTimeoutException = _RequestTimeoutException;
-    _ConflictException = class _ConflictException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 409;
-      }
-    };
-    __name(_ConflictException, "ConflictException");
-    ConflictException = _ConflictException;
-    _UpgradeRequiredException = class _UpgradeRequiredException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 426;
-      }
-    };
-    __name(_UpgradeRequiredException, "UpgradeRequiredException");
-    UpgradeRequiredException = _UpgradeRequiredException;
-    _TooManyRequestsException = class _TooManyRequestsException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 429;
-      }
-    };
-    __name(_TooManyRequestsException, "TooManyRequestsException");
-    TooManyRequestsException = _TooManyRequestsException;
-    _InternalServerException = class _InternalServerException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 500;
-      }
-    };
-    __name(_InternalServerException, "InternalServerException");
-    InternalServerException = _InternalServerException;
-    _NotImplementedException = class _NotImplementedException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 501;
-      }
-    };
-    __name(_NotImplementedException, "NotImplementedException");
-    NotImplementedException = _NotImplementedException;
-    _BadGatewayException = class _BadGatewayException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 502;
-      }
-    };
-    __name(_BadGatewayException, "BadGatewayException");
-    BadGatewayException = _BadGatewayException;
-    _ServiceUnavailableException = class _ServiceUnavailableException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 503;
-      }
-    };
-    __name(_ServiceUnavailableException, "ServiceUnavailableException");
-    ServiceUnavailableException = _ServiceUnavailableException;
-    _GatewayTimeoutException = class _GatewayTimeoutException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 504;
-      }
-    };
-    __name(_GatewayTimeoutException, "GatewayTimeoutException");
-    GatewayTimeoutException = _GatewayTimeoutException;
-    _HttpVersionNotSupportedException = class _HttpVersionNotSupportedException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 505;
-      }
-    };
-    __name(_HttpVersionNotSupportedException, "HttpVersionNotSupportedException");
-    HttpVersionNotSupportedException = _HttpVersionNotSupportedException;
-    _VariantAlsoNegotiatesException = class _VariantAlsoNegotiatesException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 506;
-      }
-    };
-    __name(_VariantAlsoNegotiatesException, "VariantAlsoNegotiatesException");
-    VariantAlsoNegotiatesException = _VariantAlsoNegotiatesException;
-    _InsufficientStorageException = class _InsufficientStorageException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 507;
-      }
-    };
-    __name(_InsufficientStorageException, "InsufficientStorageException");
-    InsufficientStorageException = _InsufficientStorageException;
-    _LoopDetectedException = class _LoopDetectedException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 508;
-      }
-    };
-    __name(_LoopDetectedException, "LoopDetectedException");
-    LoopDetectedException = _LoopDetectedException;
-    _NotExtendedException = class _NotExtendedException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 510;
-      }
-    };
-    __name(_NotExtendedException, "NotExtendedException");
-    NotExtendedException = _NotExtendedException;
-    _NetworkAuthenticationRequiredException = class _NetworkAuthenticationRequiredException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 511;
-      }
-    };
-    __name(_NetworkAuthenticationRequiredException, "NetworkAuthenticationRequiredException");
-    NetworkAuthenticationRequiredException = _NetworkAuthenticationRequiredException;
-    _NetworkConnectTimeoutException = class _NetworkConnectTimeoutException extends ResponseException {
-      constructor() {
-        super(...arguments);
-        this.status = 599;
-      }
-    };
-    __name(_NetworkConnectTimeoutException, "NetworkConnectTimeoutException");
-    NetworkConnectTimeoutException = _NetworkConnectTimeoutException;
+};
+__name(_NotExtendedException, "NotExtendedException");
+var NotExtendedException = _NotExtendedException;
+var _NetworkAuthenticationRequiredException = class _NetworkAuthenticationRequiredException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 511;
   }
-});
+};
+__name(_NetworkAuthenticationRequiredException, "NetworkAuthenticationRequiredException");
+var NetworkAuthenticationRequiredException = _NetworkAuthenticationRequiredException;
+var _NetworkConnectTimeoutException = class _NetworkConnectTimeoutException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 599;
+  }
+};
+__name(_NetworkConnectTimeoutException, "NetworkConnectTimeoutException");
+var NetworkConnectTimeoutException = _NetworkConnectTimeoutException;
 
 // src/internal/request.ts
+init_app_injector();
+var _Request = class _Request {
+  constructor(event, senderId, id, method, path2, body, query) {
+    this.event = event;
+    this.senderId = senderId;
+    this.id = id;
+    this.method = method;
+    this.path = path2;
+    this.body = body;
+    this.context = RootInjector.createScope();
+    this.params = {};
+    this.path = path2.replace(/^\/|\/$/g, "");
+    this.query = query ?? {};
+  }
+};
+__name(_Request, "Request");
+var Request = _Request;
+var RENDERER_EVENT_TYPE = "noxus:event";
 function createRendererEventMessage(event, payload) {
   return {
     type: RENDERER_EVENT_TYPE,
@@ -1016,6 +1138,7 @@ function createRendererEventMessage(event, payload) {
     payload
   };
 }
+__name(createRendererEventMessage, "createRendererEventMessage");
 function isRendererEventMessage(value) {
   if (value === null || typeof value !== "object") {
     return false;
@@ -1023,362 +1146,268 @@ function isRendererEventMessage(value) {
   const possibleMessage = value;
   return possibleMessage.type === RENDERER_EVENT_TYPE && typeof possibleMessage.event === "string";
 }
-var _Request, Request, RENDERER_EVENT_TYPE;
-var init_request = __esm({
-  "src/internal/request.ts"() {
-    "use strict";
-    init_app_injector();
-    _Request = class _Request {
-      constructor(event, senderId, id, method, path2, body) {
-        this.event = event;
-        this.senderId = senderId;
-        this.id = id;
-        this.method = method;
-        this.path = path2;
-        this.body = body;
-        this.context = RootInjector.createScope();
-        this.params = {};
-        this.path = path2.replace(/^\/|\/$/g, "");
-      }
-    };
-    __name(_Request, "Request");
-    Request = _Request;
-    RENDERER_EVENT_TYPE = "noxus:event";
-    __name(createRendererEventMessage, "createRendererEventMessage");
-    __name(isRendererEventMessage, "isRendererEventMessage");
-  }
-});
+__name(isRendererEventMessage, "isRendererEventMessage");
 
 // src/internal/router.ts
-var router_exports = {};
-__export(router_exports, {
-  Router: () => Router
-});
-var Router;
-var init_router = __esm({
-  "src/internal/router.ts"() {
-    "use strict";
-    init_controller_decorator();
-    init_injectable_decorator();
-    init_method_decorator();
-    init_injector_explorer();
-    init_logger();
-    init_radix_tree();
-    init_exceptions();
-    init_request();
-    Router = class {
-      constructor() {
-        this.routes = new RadixTree();
-        this.rootMiddlewares = [];
-        this.lazyRoutes = /* @__PURE__ */ new Map();
-      }
-      // -------------------------------------------------------------------------
-      // Registration
-      // -------------------------------------------------------------------------
-      registerController(controllerClass, pathPrefix, routeGuards = [], routeMiddlewares = []) {
-        const meta = getControllerMetadata(controllerClass);
-        if (!meta) {
-          throw new Error(`[Noxus] Missing @Controller decorator on ${controllerClass.name}`);
-        }
-        const routeMeta = getRouteMetadata(controllerClass);
-        for (const def of routeMeta) {
-          const fullPath = `${pathPrefix}/${def.path}`.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
-          const guards = [.../* @__PURE__ */ new Set([...routeGuards, ...def.guards])];
-          const middlewares = [.../* @__PURE__ */ new Set([...routeMiddlewares, ...def.middlewares])];
-          const routeDef = {
-            method: def.method,
-            path: fullPath,
-            controller: controllerClass,
-            handler: def.handler,
-            guards,
-            middlewares
-          };
-          this.routes.insert(fullPath + "/" + def.method, routeDef);
-          const guardInfo = guards.length ? `<${guards.map((g) => g.name).join("|")}>` : "";
-          Logger.log(`Mapped {${def.method} /${fullPath}}${guardInfo} route`);
-        }
-        const ctrlGuardInfo = routeGuards.length ? `<${routeGuards.map((g) => g.name).join("|")}>` : "";
-        Logger.log(`Mapped ${controllerClass.name}${ctrlGuardInfo} controller's routes`);
-        return this;
-      }
-      registerLazyRoute(pathPrefix, load, guards = [], middlewares = []) {
-        const normalized = pathPrefix.replace(/^\/+|\/+$/g, "");
-        this.lazyRoutes.set(normalized, { load, guards, middlewares, loading: null, loaded: false });
-        Logger.log(`Registered lazy route prefix {${normalized}}`);
-        return this;
-      }
-      defineRootMiddleware(middleware) {
-        this.rootMiddlewares.push(middleware);
-        return this;
-      }
-      // -------------------------------------------------------------------------
-      // Request handling
-      // -------------------------------------------------------------------------
-      async handle(request) {
-        return request.method === "BATCH" ? this.handleBatch(request) : this.handleAtomic(request);
-      }
-      async handleAtomic(request) {
-        Logger.comment(`>     ${request.method} /${request.path}`);
-        const t0 = performance.now();
-        const response = { requestId: request.id, status: 200, body: null };
-        let isCritical = false;
-        try {
-          const routeDef = await this.findRoute(request);
-          await this.resolveController(request, response, routeDef);
-          if (response.status >= 400) throw new ResponseException(response.status, response.error);
-        } catch (error) {
-          this.fillErrorResponse(response, error, (c) => {
-            isCritical = c;
-          });
-        } finally {
-          this.logResponse(request, response, performance.now() - t0, isCritical);
-          return response;
-        }
-      }
-      async handleBatch(request) {
-        Logger.comment(`>     ${request.method} /${request.path}`);
-        const t0 = performance.now();
-        const response = {
-          requestId: request.id,
-          status: 200,
-          body: { responses: [] }
-        };
-        let isCritical = false;
-        try {
-          const payload = this.normalizeBatchPayload(request.body);
-          response.body.responses = await Promise.all(
-            payload.requests.map((item, i) => {
-              const id = item.requestId ?? `${request.id}:${i}`;
-              return this.handleAtomic(new Request(request.event, request.senderId, id, item.method, item.path, item.body));
-            })
-          );
-        } catch (error) {
-          this.fillErrorResponse(response, error, (c) => {
-            isCritical = c;
-          });
-        } finally {
-          this.logResponse(request, response, performance.now() - t0, isCritical);
-          return response;
-        }
-      }
-      // -------------------------------------------------------------------------
-      // Route resolution
-      // -------------------------------------------------------------------------
-      tryFindRoute(request) {
-        const matched = this.routes.search(request.path);
-        if (!matched?.node || matched.node.children.length === 0) return void 0;
-        return matched.node.findExactChild(request.method)?.value;
-      }
-      async findRoute(request) {
-        const direct = this.tryFindRoute(request);
-        if (direct) return direct;
-        await this.tryLoadLazyRoute(request.path);
-        const afterLazy = this.tryFindRoute(request);
-        if (afterLazy) return afterLazy;
-        throw new NotFoundException(`No route matches ${request.method} ${request.path}`);
-      }
-      async tryLoadLazyRoute(requestPath) {
-        const firstSegment = requestPath.replace(/^\/+/, "").split("/")[0] ?? "";
-        for (const [prefix, entry] of this.lazyRoutes) {
-          if (entry.loaded) continue;
-          const normalized = requestPath.replace(/^\/+/, "");
-          if (normalized === prefix || normalized.startsWith(prefix + "/") || firstSegment === prefix) {
-            if (!entry.loading) entry.loading = this.loadLazyModule(prefix, entry);
-            await entry.loading;
-            return;
-          }
-        }
-      }
-      async loadLazyModule(prefix, entry) {
-        const t0 = performance.now();
-        InjectorExplorer.beginAccumulate();
-        await entry.load?.();
-        entry.loading = null;
-        entry.load = null;
-        InjectorExplorer.flushAccumulated(entry.guards, entry.middlewares, prefix);
-        entry.loaded = true;
-        Logger.info(`Lazy-loaded module for prefix {${prefix}} in ${Math.round(performance.now() - t0)}ms`);
-      }
-      // -------------------------------------------------------------------------
-      // Pipeline
-      // -------------------------------------------------------------------------
-      async resolveController(request, response, routeDef) {
-        const instance = request.context.resolve(routeDef.controller);
-        Object.assign(request.params, this.extractParams(request.path, routeDef.path));
-        await this.runPipeline(request, response, routeDef, instance);
-      }
-      async runPipeline(request, response, routeDef, controllerInstance) {
-        const middlewares = [.../* @__PURE__ */ new Set([...this.rootMiddlewares, ...routeDef.middlewares])];
-        const mwMax = middlewares.length - 1;
-        const guardMax = mwMax + routeDef.guards.length;
-        let index = -1;
-        const dispatch = /* @__PURE__ */ __name(async (i) => {
-          if (i <= index) throw new Error("next() called multiple times");
-          index = i;
-          if (i <= mwMax) {
-            await this.runMiddleware(request, response, dispatch.bind(null, i + 1), middlewares[i]);
-            if (response.status >= 400) throw new ResponseException(response.status, response.error);
-            return;
-          }
-          if (i <= guardMax) {
-            await this.runGuard(request, routeDef.guards[i - middlewares.length]);
-            await dispatch(i + 1);
-            return;
-          }
-          const action = controllerInstance[routeDef.handler];
-          response.body = await action.call(controllerInstance, request, response);
-          if (response.body === void 0) response.body = {};
-        }, "dispatch");
-        await dispatch(0);
-      }
-      async runMiddleware(request, response, next, middleware) {
-        await middleware(request, response, next);
-      }
-      async runGuard(request, guard) {
-        if (!await guard(request)) {
-          throw new UnauthorizedException(`Unauthorized for ${request.method} ${request.path}`);
-        }
-      }
-      // -------------------------------------------------------------------------
-      // Utilities
-      // -------------------------------------------------------------------------
-      extractParams(actual, template) {
-        const aParts = actual.split("/");
-        const tParts = template.split("/");
-        const params = {};
-        tParts.forEach((part, i) => {
-          if (part.startsWith(":")) params[part.slice(1)] = aParts[i] ?? "";
-        });
-        return params;
-      }
-      normalizeBatchPayload(body) {
-        if (body === null || typeof body !== "object") {
-          throw new BadRequestException("Batch payload must be an object containing a requests array.");
-        }
-        const { requests } = body;
-        if (!Array.isArray(requests)) throw new BadRequestException("Batch payload must define a requests array.");
-        return { requests: requests.map((e, i) => this.normalizeBatchItem(e, i)) };
-      }
-      normalizeBatchItem(entry, index) {
-        if (entry === null || typeof entry !== "object") throw new BadRequestException(`Batch request at index ${index} must be an object.`);
-        const { requestId, path: path2, method, body } = entry;
-        if (requestId !== void 0 && typeof requestId !== "string") throw new BadRequestException(`Batch request at index ${index} has an invalid requestId.`);
-        if (typeof path2 !== "string" || !path2.length) throw new BadRequestException(`Batch request at index ${index} must define a non-empty path.`);
-        if (typeof method !== "string") throw new BadRequestException(`Batch request at index ${index} must define an HTTP method.`);
-        const normalized = method.toUpperCase();
-        if (!isAtomicHttpMethod(normalized)) throw new BadRequestException(`Batch request at index ${index} uses unsupported method ${method}.`);
-        return { requestId, path: path2, method: normalized, body };
+var Router = class {
+  constructor() {
+    this.routes = new RadixTree();
+    this.rootMiddlewares = [];
+    this.lazyRoutes = /* @__PURE__ */ new Map();
+  }
+  // -------------------------------------------------------------------------
+  // Registration
+  // -------------------------------------------------------------------------
+  registerController(controllerClass, pathPrefix, routeGuards = [], routeMiddlewares = []) {
+    const meta = getControllerMetadata(controllerClass);
+    if (!meta) {
+      throw new Error(`[Noxus] Missing @Controller decorator on ${controllerClass.name}`);
+    }
+    const routeMeta = getRouteMetadata(controllerClass);
+    for (const def of routeMeta) {
+      const fullPath = `${pathPrefix}/${def.path}`.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+      const guards = [.../* @__PURE__ */ new Set([...routeGuards, ...def.guards])];
+      const middlewares = [.../* @__PURE__ */ new Set([...routeMiddlewares, ...def.middlewares])];
+      const routeDef = {
+        method: def.method,
+        path: fullPath,
+        controller: controllerClass,
+        handler: def.handler,
+        guards,
+        middlewares
+      };
+      this.routes.insert(fullPath + "/" + def.method, routeDef);
+      const guardInfo = guards.length ? `<${guards.map((g) => g.name).join("|")}>` : "";
+      Logger.log(`Mapped {${def.method} /${fullPath}}${guardInfo} route`);
+    }
+    const ctrlGuardInfo = routeGuards.length ? `<${routeGuards.map((g) => g.name).join("|")}>` : "";
+    Logger.log(`Mapped ${controllerClass.name}${ctrlGuardInfo} controller's routes`);
+    return this;
+  }
+  registerLazyRoute(pathPrefix, load, guards = [], middlewares = []) {
+    const normalized = pathPrefix.replace(/^\/+|\/+$/g, "");
+    this.lazyRoutes.set(normalized, { load, guards, middlewares, loading: null, loaded: false });
+    Logger.log(`Registered lazy route prefix {${normalized}}`);
+    return this;
+  }
+  defineRootMiddleware(middleware) {
+    this.rootMiddlewares.push(middleware);
+    return this;
+  }
+  getRegisteredRoutes() {
+    const allRoutes = this.routes.collectValues();
+    return allRoutes.map((r) => ({ method: r.method, path: r.path }));
+  }
+  getLazyRoutes() {
+    return [...this.lazyRoutes.entries()].map(([prefix, entry]) => ({
+      prefix,
+      loaded: entry.loaded
+    }));
+  }
+  // -------------------------------------------------------------------------
+  // Request handling
+  // -------------------------------------------------------------------------
+  async handle(request) {
+    return request.method === "BATCH" ? this.handleBatch(request) : this.handleAtomic(request);
+  }
+  async handleAtomic(request) {
+    Logger.comment(`>     ${request.method} /${request.path}`);
+    const t0 = performance.now();
+    const response = { requestId: request.id, status: 200, body: null };
+    let isCritical = false;
+    try {
+      const routeDef = await this.findRoute(request);
+      await this.resolveController(request, response, routeDef);
+      if (response.status >= 400) throw new ResponseException(response.status, response.error);
+    } catch (error) {
+      this.fillErrorResponse(response, error, (c) => {
+        isCritical = c;
+      });
+    } finally {
+      this.logResponse(request, response, performance.now() - t0, isCritical);
+      return response;
+    }
+  }
+  async handleBatch(request) {
+    Logger.comment(`>     ${request.method} /${request.path}`);
+    const t0 = performance.now();
+    const response = {
+      requestId: request.id,
+      status: 200,
+      body: { responses: [] }
+    };
+    let isCritical = false;
+    try {
+      const payload = this.normalizeBatchPayload(request.body);
+      response.body.responses = await Promise.all(
+        payload.requests.map((item, i) => {
+          const id = item.requestId ?? `${request.id}:${i}`;
+          return this.handleAtomic(new Request(request.event, request.senderId, id, item.method, item.path, item.body, item.query));
+        })
+      );
+    } catch (error) {
+      this.fillErrorResponse(response, error, (c) => {
+        isCritical = c;
+      });
+    } finally {
+      this.logResponse(request, response, performance.now() - t0, isCritical);
+      return response;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Route resolution
+  // -------------------------------------------------------------------------
+  tryFindRoute(request) {
+    const matched = this.routes.search(request.path);
+    if (!matched?.node || matched.node.children.length === 0) return void 0;
+    return matched.node.findExactChild(request.method)?.value;
+  }
+  async findRoute(request) {
+    const direct = this.tryFindRoute(request);
+    if (direct) return direct;
+    await this.tryLoadLazyRoute(request.path);
+    const afterLazy = this.tryFindRoute(request);
+    if (afterLazy) return afterLazy;
+    throw new NotFoundException(`No route matches ${request.method} ${request.path}`);
+  }
+  async tryLoadLazyRoute(requestPath) {
+    const firstSegment = requestPath.replace(/^\/+/, "").split("/")[0] ?? "";
+    for (const [prefix, entry] of this.lazyRoutes) {
+      if (entry.loaded) continue;
+      const normalized = requestPath.replace(/^\/+/, "");
+      if (normalized === prefix || normalized.startsWith(prefix + "/") || firstSegment === prefix) {
+        if (!entry.loading) entry.loading = this.loadLazyModule(prefix, entry);
+        await entry.loading;
+        return;
       }
-      fillErrorResponse(response, error, setCritical) {
-        response.body = void 0;
-        if (error instanceof ResponseException) {
-          response.status = error.status;
-          response.error = error.message;
-          response.stack = error.stack;
-        } else if (error instanceof Error) {
-          setCritical(true);
-          response.status = 500;
-          response.error = error.message || "Internal Server Error";
-          response.stack = error.stack;
-        } else {
-          setCritical(true);
-          response.status = 500;
-          response.error = "Unknown error occurred";
-        }
+    }
+  }
+  async loadLazyModule(prefix, entry) {
+    const t0 = performance.now();
+    InjectorExplorer.beginAccumulate();
+    await entry.load?.();
+    entry.loading = null;
+    entry.load = null;
+    await InjectorExplorer.flushAccumulated(entry.guards, entry.middlewares, prefix);
+    entry.loaded = true;
+    Logger.info(`Lazy-loaded module for prefix {${prefix}} in ${Math.round(performance.now() - t0)}ms`);
+  }
+  // -------------------------------------------------------------------------
+  // Pipeline
+  // -------------------------------------------------------------------------
+  async resolveController(request, response, routeDef) {
+    const instance = request.context.resolve(routeDef.controller);
+    Object.assign(request.params, this.extractParams(request.path, routeDef.path));
+    await this.runPipeline(request, response, routeDef, instance);
+  }
+  async runPipeline(request, response, routeDef, controllerInstance) {
+    const middlewares = [.../* @__PURE__ */ new Set([...this.rootMiddlewares, ...routeDef.middlewares])];
+    const mwMax = middlewares.length - 1;
+    const guardMax = mwMax + routeDef.guards.length;
+    let index = -1;
+    const dispatch = /* @__PURE__ */ __name(async (i) => {
+      if (i <= index) throw new Error("next() called multiple times");
+      index = i;
+      if (i <= mwMax) {
+        await this.runMiddleware(request, response, dispatch.bind(null, i + 1), middlewares[i]);
+        if (response.status >= 400) throw new ResponseException(response.status, response.error);
+        return;
       }
-      logResponse(request, response, ms, isCritical) {
-        const msg = `< ${response.status} ${request.method} /${request.path} ${Logger.colors.yellow}${Math.round(ms)}ms${Logger.colors.initial}`;
-        if (response.status < 400) Logger.log(msg);
-        else if (response.status < 500) Logger.warn(msg);
-        else isCritical ? Logger.critical(msg) : Logger.error(msg);
-        if (response.error) {
-          isCritical ? Logger.critical(response.error) : Logger.error(response.error);
-          if (response.stack) Logger.errorStack(response.stack);
-        }
+      if (i <= guardMax) {
+        await this.runGuard(request, routeDef.guards[i - middlewares.length]);
+        await dispatch(i + 1);
+        return;
       }
-    };
-    __name(Router, "Router");
-    Router = __decorateClass([
-      Injectable({ lifetime: "singleton" })
-    ], Router);
+      const action = controllerInstance[routeDef.handler];
+      response.body = await action.call(controllerInstance, request, response);
+      if (response.body === void 0) response.body = {};
+    }, "dispatch");
+    await dispatch(0);
   }
-});
-
-// src/main.ts
-var main_exports = {};
-__export(main_exports, {
-  AppInjector: () => AppInjector,
-  BadGatewayException: () => BadGatewayException,
-  BadRequestException: () => BadRequestException,
-  ConflictException: () => ConflictException,
-  Controller: () => Controller,
-  Delete: () => Delete,
-  ForbiddenException: () => ForbiddenException,
-  ForwardReference: () => ForwardReference,
-  GatewayTimeoutException: () => GatewayTimeoutException,
-  Get: () => Get,
-  HttpVersionNotSupportedException: () => HttpVersionNotSupportedException,
-  Injectable: () => Injectable,
-  InsufficientStorageException: () => InsufficientStorageException,
-  InternalServerException: () => InternalServerException,
-  Logger: () => Logger,
-  LoopDetectedException: () => LoopDetectedException,
-  MethodNotAllowedException: () => MethodNotAllowedException,
-  NetworkAuthenticationRequiredException: () => NetworkAuthenticationRequiredException,
-  NetworkConnectTimeoutException: () => NetworkConnectTimeoutException,
-  NotAcceptableException: () => NotAcceptableException,
-  NotExtendedException: () => NotExtendedException,
-  NotFoundException: () => NotFoundException,
-  NotImplementedException: () => NotImplementedException,
-  NoxApp: () => NoxApp,
-  NoxSocket: () => NoxSocket,
-  Patch: () => Patch,
-  PaymentRequiredException: () => PaymentRequiredException,
-  Post: () => Post,
-  Put: () => Put,
-  RENDERER_EVENT_TYPE: () => RENDERER_EVENT_TYPE,
-  Request: () => Request,
-  RequestTimeoutException: () => RequestTimeoutException,
-  ResponseException: () => ResponseException,
-  RootInjector: () => RootInjector,
-  Router: () => Router,
-  ServiceUnavailableException: () => ServiceUnavailableException,
-  Token: () => Token,
-  TooManyRequestsException: () => TooManyRequestsException,
-  UnauthorizedException: () => UnauthorizedException,
-  UpgradeRequiredException: () => UpgradeRequiredException,
-  VariantAlsoNegotiatesException: () => VariantAlsoNegotiatesException,
-  WindowManager: () => WindowManager,
-  bootstrapApplication: () => bootstrapApplication,
-  createRendererEventMessage: () => createRendererEventMessage,
-  defineRoutes: () => defineRoutes,
-  forwardRef: () => forwardRef,
-  getControllerMetadata: () => getControllerMetadata,
-  getRouteMetadata: () => getRouteMetadata,
-  inject: () => inject,
-  isAtomicHttpMethod: () => isAtomicHttpMethod,
-  isRendererEventMessage: () => isRendererEventMessage,
-  token: () => token
-});
-module.exports = __toCommonJS(main_exports);
-init_app_injector();
-init_token();
-init_router();
+  async runMiddleware(request, response, next, middleware) {
+    await middleware(request, response, next);
+  }
+  async runGuard(request, guard) {
+    if (!await guard(request)) {
+      throw new UnauthorizedException(`Unauthorized for ${request.method} ${request.path}`);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Utilities
+  // -------------------------------------------------------------------------
+  extractParams(actual, template) {
+    const aParts = actual.split("/");
+    const tParts = template.split("/");
+    const params = {};
+    tParts.forEach((part, i) => {
+      if (part.startsWith(":")) params[part.slice(1)] = aParts[i] ?? "";
+    });
+    return params;
+  }
+  normalizeBatchPayload(body) {
+    if (body === null || typeof body !== "object") {
+      throw new BadRequestException("Batch payload must be an object containing a requests array.");
+    }
+    const { requests } = body;
+    if (!Array.isArray(requests)) throw new BadRequestException("Batch payload must define a requests array.");
+    return { requests: requests.map((e, i) => this.normalizeBatchItem(e, i)) };
+  }
+  normalizeBatchItem(entry, index) {
+    if (entry === null || typeof entry !== "object") throw new BadRequestException(`Batch request at index ${index} must be an object.`);
+    const { requestId, path: path2, method, body } = entry;
+    if (requestId !== void 0 && typeof requestId !== "string") throw new BadRequestException(`Batch request at index ${index} has an invalid requestId.`);
+    if (typeof path2 !== "string" || !path2.length) throw new BadRequestException(`Batch request at index ${index} must define a non-empty path.`);
+    if (typeof method !== "string") throw new BadRequestException(`Batch request at index ${index} must define an HTTP method.`);
+    const normalized = method.toUpperCase();
+    if (!isAtomicHttpMethod(normalized)) throw new BadRequestException(`Batch request at index ${index} uses unsupported method ${method}.`);
+    return { requestId, path: path2, method: normalized, body };
+  }
+  fillErrorResponse(response, error, setCritical) {
+    response.body = void 0;
+    if (error instanceof ResponseException) {
+      response.status = error.status;
+      response.error = error.message;
+      response.stack = error.stack;
+    } else if (error instanceof Error) {
+      setCritical(true);
+      response.status = 500;
+      response.error = error.message || "Internal Server Error";
+      response.stack = error.stack;
+    } else {
+      setCritical(true);
+      response.status = 500;
+      response.error = "Unknown error occurred";
+    }
+  }
+  logResponse(request, response, ms, isCritical) {
+    const msg = `< ${response.status} ${request.method} /${request.path} ${Logger.colors.yellow}${Math.round(ms)}ms${Logger.colors.initial}`;
+    if (response.status < 400) Logger.log(msg);
+    else if (response.status < 500) Logger.warn(msg);
+    else isCritical ? Logger.critical(msg) : Logger.error(msg);
+    if (response.error) {
+      isCritical ? Logger.critical(response.error) : Logger.error(response.error);
+      if (response.stack) Logger.errorStack(response.stack);
+    }
+  }
+};
+__name(Router, "Router");
+Router = __decorateClass([
+  Injectable({ lifetime: "singleton" })
+], Router);
 
 // src/internal/app.ts
 var import_main2 = require("electron/main");
-init_injectable_decorator();
 init_app_injector();
 init_injector_explorer();
 init_logger();
 
 // src/window/window-manager.ts
 var import_main = require("electron/main");
-init_injectable_decorator();
 init_logger();
 var WindowManager = class {
   constructor() {
     this._windows = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
   }
   // -------------------------------------------------------------------------
   // Creation
@@ -1510,6 +1539,18 @@ var WindowManager = class {
     }
   }
   // -------------------------------------------------------------------------
+  // Events
+  // -------------------------------------------------------------------------
+  on(event, handler) {
+    const set = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(handler);
+    this.listeners.set(event, set);
+    return () => set.delete(handler);
+  }
+  _emit(event, win) {
+    this.listeners.get(event)?.forEach((h) => h(win));
+  }
+  // -------------------------------------------------------------------------
   // Private
   // -------------------------------------------------------------------------
   _register(win, isMain) {
@@ -1517,12 +1558,16 @@ var WindowManager = class {
     if (isMain && this._mainWindowId === void 0) {
       this._mainWindowId = win.id;
     }
+    this._emit("created", win);
+    win.on("focus", () => this._emit("focused", win));
+    win.on("blur", () => this._emit("blurred", win));
     win.once("closed", () => {
       this._windows.delete(win.id);
       if (this._mainWindowId === win.id) {
         this._mainWindowId = void 0;
       }
       Logger.log(`[WindowManager] Window #${win.id} closed`);
+      this._emit("closed", win);
     });
   }
   /**
@@ -1552,14 +1597,8 @@ WindowManager = __decorateClass([
   Injectable({ lifetime: "singleton" })
 ], WindowManager);
 
-// src/internal/app.ts
-init_request();
-init_router();
-
 // src/internal/socket.ts
-init_injectable_decorator();
 init_logger();
-init_request();
 var NoxSocket = class {
   constructor() {
     this.channels = /* @__PURE__ */ new Map();
@@ -1582,7 +1621,6 @@ var NoxSocket = class {
       throw new Error("Renderer event name must be a non-empty string.");
     }
     const recipients = targetSenderIds ?? this.getSenderIds();
-    let delivered = 0;
     for (const senderId of recipients) {
       const channel = this.channels.get(senderId);
       if (!channel) {
@@ -1591,15 +1629,17 @@ var NoxSocket = class {
       }
       try {
         channel.socket.port1.postMessage(createRendererEventMessage(normalizedEvent, payload));
-        delivered++;
       } catch (error) {
         Logger.error(`[Noxus] Failed to emit "${normalizedEvent}" to sender ${senderId}.`, error);
       }
     }
-    return delivered;
   }
   emitToRenderer(senderId, eventName, payload) {
-    return this.emit(eventName, payload, [senderId]) > 0;
+    if (!this.channels.has(senderId)) {
+      return false;
+    }
+    this.emit(eventName, payload, [senderId]);
+    return true;
   }
 };
 __name(NoxSocket, "NoxSocket");
@@ -1609,22 +1649,22 @@ NoxSocket = __decorateClass([
 
 // src/internal/app.ts
 var NoxApp = class {
-  constructor() {
-    this.router = inject(Router);
-    this.socket = inject(NoxSocket);
-    this.windowManager = inject(WindowManager);
+  constructor(router, socket, windowManager) {
+    this.router = router;
+    this.socket = socket;
+    this.windowManager = windowManager;
     // -------------------------------------------------------------------------
     // IPC
     // -------------------------------------------------------------------------
     this.onRendererMessage = /* @__PURE__ */ __name(async (event) => {
-      const { senderId, requestId, path: path2, method, body } = event.data;
+      const { senderId, requestId, path: path2, method, body, query } = event.data;
       const channels = this.socket.get(senderId);
       if (!channels) {
         Logger.error(`No message channel found for sender ID: ${senderId}`);
         return;
       }
       try {
-        const request = new Request(event, senderId, requestId, method, path2, body);
+        const request = new Request(event, senderId, requestId, method, path2, body, query);
         const response = await this.router.handle(request);
         channels.request.port1.postMessage(response);
       } catch (err) {
@@ -1675,7 +1715,7 @@ var NoxApp = class {
   async load(importFns) {
     InjectorExplorer.beginAccumulate();
     await Promise.all(importFns.map((fn) => fn()));
-    InjectorExplorer.flushAccumulated();
+    await InjectorExplorer.flushAccumulated();
     return this;
   }
   /**
@@ -1753,18 +1793,34 @@ NoxApp = __decorateClass([
 var import_main3 = require("electron/main");
 init_app_injector();
 init_injector_explorer();
+init_logger();
 async function bootstrapApplication(config = {}) {
   await import_main3.app.whenReady();
+  if (config.logLevel !== void 0) {
+    if (config.logLevel === "none") {
+      Logger.setLogLevel([]);
+    } else if (Array.isArray(config.logLevel)) {
+      Logger.setLogLevel(config.logLevel);
+    } else {
+      Logger.setLogLevel(config.logLevel);
+    }
+  }
   const overrides = /* @__PURE__ */ new Map();
   for (const { token: token2, useValue } of config.singletons ?? []) {
     overrides.set(token2, useValue);
     RootInjector.singletons.set(token2, useValue);
   }
+  InjectorExplorer.setControllerRegistrar((controllerClass, pathPrefix, routeGuards, routeMiddlewares) => {
+    const router = inject(Router);
+    router.registerController(controllerClass, pathPrefix, routeGuards, routeMiddlewares);
+  });
   InjectorExplorer.processPending(overrides);
   const noxApp = inject(NoxApp);
   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);
+      }
     }
   }
   if (config.eagerLoad?.length) {
@@ -1776,29 +1832,53 @@ async function bootstrapApplication(config = {}) {
 __name(bootstrapApplication, "bootstrapApplication");
 
 // src/main.ts
-init_exceptions();
-init_controller_decorator();
-init_injectable_decorator();
-init_method_decorator();
 init_logger();
 init_forward_ref();
-init_request();
 
 // src/internal/routes.ts
 function defineRoutes(routes) {
-  const paths = routes.map((r) => r.path.replace(/^\/+|\/+$/g, ""));
+  const flat = flattenRoutes(routes);
+  const paths = flat.map((r) => r.path);
   const duplicates = paths.filter((p, i) => paths.indexOf(p) !== i);
   if (duplicates.length > 0) {
     throw new Error(
       `[Noxus] Duplicate route prefixes detected: ${[...new Set(duplicates)].map((d) => `"${d}"`).join(", ")}`
     );
   }
-  return routes.map((r) => ({
-    ...r,
-    path: r.path.replace(/^\/+|\/+$/g, "")
-  }));
+  const sorted = [...paths].sort();
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const a = sorted[i];
+    const b = sorted[i + 1];
+    if (b.startsWith(a + "/")) {
+      throw new Error(
+        `[Noxus] Overlapping route prefixes detected: "${a}" and "${b}". Use nested children under "${a}" instead of declaring both as top-level routes.`
+      );
+    }
+  }
+  return flat;
 }
 __name(defineRoutes, "defineRoutes");
+function flattenRoutes(routes, parentPath = "", parentGuards = [], parentMiddlewares = []) {
+  const result = [];
+  for (const route of routes) {
+    const path2 = [parentPath, route.path.replace(/^\/+|\/+$/g, "")].filter(Boolean).join("/");
+    const guards = [.../* @__PURE__ */ new Set([...parentGuards, ...route.guards ?? []])];
+    const middlewares = [.../* @__PURE__ */ new Set([...parentMiddlewares, ...route.middlewares ?? []])];
+    if (route.load) {
+      result.push({ ...route, path: path2, guards, middlewares });
+    }
+    if (route.children?.length) {
+      result.push(...flattenRoutes(route.children, path2, guards, middlewares));
+    }
+    if (!route.load && !route.children?.length) {
+      throw new Error(
+        `[Noxus] Route "${path2}" has neither a load function nor children. It must have at least one of them.`
+      );
+    }
+  }
+  return result;
+}
+__name(flattenRoutes, "flattenRoutes");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AppInjector,
@@ -1852,6 +1932,7 @@ __name(defineRoutes, "defineRoutes");
   inject,
   isAtomicHttpMethod,
   isRendererEventMessage,
+  resetRootInjector,
   token
 });
 /**