@noxfly/noxus 3.0.0-dev.1 → 3.0.0-dev.11

package/dist/main.js

@@ -10,6 +10,11 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 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;
@@ -35,14 +40,45 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/utils/forward-ref.ts
 function forwardRef(fn) {
@@ -74,6 +110,7 @@ var init_token = __esm({
     _Token = class _Token {
       constructor(target) {
         this.target = target;
+        __publicField(this, "description");
         this.description = typeof target === "string" ? target : target.name;
       }
       toString() {
@@ -86,113 +123,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);
-        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();
@@ -441,6 +371,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"() {
@@ -451,6 +385,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);
@@ -476,16 +417,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
@@ -496,8 +458,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);
@@ -509,9 +478,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}`);
           }
@@ -522,782 +497,135 @@ 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, "", [], []);
         }
       }
     };
     __name(_InjectorExplorer, "InjectorExplorer");
-    _InjectorExplorer.pending = [];
-    _InjectorExplorer.processed = false;
-    _InjectorExplorer.accumulating = false;
+    __publicField(_InjectorExplorer, "pending", []);
+    __publicField(_InjectorExplorer, "processed", false);
+    __publicField(_InjectorExplorer, "accumulating", false);
+    __publicField(_InjectorExplorer, "loadingLock", Promise.resolve());
+    __publicField(_InjectorExplorer, "controllerRegistrar", null);
     InjectorExplorer = _InjectorExplorer;
   }
 });
 
-// src/decorators/controller.decorator.ts
-function Controller(options = {}) {
-  return (target) => {
-    const meta = {
-      deps: options.deps ?? []
-    };
-    controllerMetaMap.set(target, meta);
-    InjectorExplorer.enqueue({
-      key: target,
-      implementation: target,
-      lifetime: "scope",
-      deps: options.deps ?? [],
-      isController: true
-    });
-  };
+// src/DI/app-injector.ts
+function keyOf(k) {
+  return k;
 }
-function getControllerMetadata(target) {
-  return controllerMetaMap.get(target);
+function resetRootInjector() {
+  RootInjector.bindings.clear();
+  RootInjector.singletons.clear();
+  RootInjector.scoped.clear();
+  const { InjectorExplorer: InjectorExplorer2 } = (init_injector_explorer(), __toCommonJS(injector_explorer_exports));
+  InjectorExplorer2.reset();
 }
-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");
-  }
-});
-
-// src/decorators/injectable.decorator.ts
-function Injectable(options = {}) {
-  const { lifetime = "scope", deps = [] } = options;
-  return (target) => {
-    if (typeof target !== "function" || !target.prototype) {
-      throw new Error(`@Injectable can only be applied to classes, not ${typeof target}`);
-    }
-    const key = target;
-    InjectorExplorer.enqueue({
-      key,
-      implementation: key,
-      lifetime,
-      deps,
-      isController: false
-    });
-  };
+function inject(t) {
+  return RootInjector.resolve(t);
 }
-var init_injectable_decorator = __esm({
-  "src/decorators/injectable.decorator.ts"() {
+var _AppInjector, AppInjector, RootInjector;
+var init_app_injector = __esm({
+  "src/DI/app-injector.ts"() {
     "use strict";
-    init_injector_explorer();
+    init_forward_ref();
     init_token();
-    __name(Injectable, "Injectable");
-  }
-});
-
-// src/decorators/method.decorator.ts
-function isAtomicHttpMethod(m) {
-  return typeof m === "string" && ATOMIC_METHODS.has(m);
-}
-function createRouteDecorator(verb) {
-  return (path2, options = {}) => {
-    return (target, propertyKey) => {
-      const ctor = target.constructor;
-      const existing = routeMetaMap.get(ctor) ?? [];
-      existing.push({
-        method: verb,
-        path: (path2 ?? "").trim().replace(/^\/|\/$/g, ""),
-        handler: propertyKey,
-        guards: options.guards ?? [],
-        middlewares: options.middlewares ?? []
-      });
-      routeMetaMap.set(ctor, existing);
-    };
-  };
-}
-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");
-  }
-});
-
-// 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);
+    __name(keyOf, "keyOf");
+    _AppInjector = class _AppInjector {
+      constructor(name = null) {
+        this.name = name;
+        __publicField(this, "bindings", /* @__PURE__ */ new Map());
+        __publicField(this, "singletons", /* @__PURE__ */ new Map());
+        __publicField(this, "scoped", /* @__PURE__ */ new Map());
       }
       /**
-       * 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.
+       * Creates a child scope for per-request lifetime resolution.
        */
-      addChild(node) {
-        this.children.push(node);
-      }
-    };
-    __name(_RadixNode, "RadixNode");
-    RadixNode = _RadixNode;
-    _RadixTree = class _RadixTree {
-      constructor() {
-        this.root = new RadixNode("");
+      createScope() {
+        const scope = new _AppInjector();
+        scope.bindings = this.bindings;
+        scope.singletons = this.singletons;
+        return scope;
       }
       /**
-       * 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.
+       * Registers a binding explicitly.
        */
-      insert(path2, value) {
-        const segments = this.normalize(path2);
-        this.insertRecursive(this.root, segments, value);
+      register(key, implementation, lifetime, deps = []) {
+        const k = keyOf(key);
+        if (!this.bindings.has(k)) {
+          this.bindings.set(k, { lifetime, implementation, deps });
+        }
       }
       /**
-       * 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.
+       * Resolves a dependency by token or class reference.
        */
-      insertRecursive(node, segments, value) {
-        if (segments.length === 0) {
-          node.value = value;
-          return;
+      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 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);
+        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 })?`
+          );
         }
-        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
-            };
+        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;
           }
-          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
-              };
+          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;
             }
-            const result = this.searchRecursive(child, rest, params);
-            if (result)
-              return result;
+            return inst;
           }
         }
-        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;
-  }
-});
-
-// 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;
-  }
-});
-
-// src/internal/request.ts
-function createRendererEventMessage(event, payload) {
-  return {
-    type: RENDERER_EVENT_TYPE,
-    event,
-    payload
-  };
-}
-function isRendererEventMessage(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  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");
-  }
-});
-
-// 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] ?? "";
+      _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")
         });
-        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);
-        }
+      _instantiate(binding) {
+        const resolvedDeps = binding.deps.map((dep) => this.resolve(dep));
+        return new binding.implementation(...resolvedDeps);
       }
     };
-    __name(Router, "Router");
-    Router = __decorateClass([
-      Injectable({ lifetime: "singleton" })
-    ], Router);
+    __name(_AppInjector, "AppInjector");
+    AppInjector = _AppInjector;
+    RootInjector = new AppInjector("root");
+    __name(resetRootInjector, "resetRootInjector");
+    __name(inject, "inject");
   }
 });
 
@@ -1355,27 +683,789 @@ __export(main_exports, {
   inject: () => inject,
   isAtomicHttpMethod: () => isAtomicHttpMethod,
   isRendererEventMessage: () => isRendererEventMessage,
+  resetRootInjector: () => resetRootInjector,
   token: () => token
 });
 module.exports = __toCommonJS(main_exports);
 init_app_injector();
 init_token();
-init_router();
+
+// src/decorators/controller.decorator.ts
+init_injector_explorer();
+var controllerMetaMap = /* @__PURE__ */ new WeakMap();
+function Controller(options = {}) {
+  return (target, _context) => {
+    const meta = {
+      deps: options.deps ?? []
+    };
+    controllerMetaMap.set(target, meta);
+    InjectorExplorer.enqueue({
+      key: target,
+      implementation: target,
+      lifetime: "scope",
+      deps: options.deps ?? [],
+      isController: true
+    });
+  };
+}
+__name(Controller, "Controller");
+function getControllerMetadata(target) {
+  return controllerMetaMap.get(target);
+}
+__name(getControllerMetadata, "getControllerMetadata");
+
+// src/decorators/injectable.decorator.ts
+init_injector_explorer();
+init_token();
+function Injectable(options = {}) {
+  const { lifetime = "scope", deps = [] } = options;
+  return (target, _context) => {
+    const key = target;
+    InjectorExplorer.enqueue({
+      key,
+      implementation: key,
+      lifetime,
+      deps,
+      isController: false
+    });
+  };
+}
+__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 methodMeta = /* @__PURE__ */ new WeakMap();
+function createRouteDecorator(verb) {
+  return (path2, options = {}) => {
+    return (value, context) => {
+      methodMeta.set(value, {
+        method: verb,
+        path: (path2 ?? "").trim().replace(/^\/|\/$/g, ""),
+        handler: context.name,
+        guards: options.guards ?? [],
+        middlewares: options.middlewares ?? []
+      });
+    };
+  };
+}
+__name(createRouteDecorator, "createRouteDecorator");
+function getRouteMetadata(target) {
+  const routes = [];
+  const proto = target.prototype;
+  for (const key of Object.getOwnPropertyNames(proto)) {
+    const fn = proto[key];
+    if (typeof fn === "function" && methodMeta.has(fn)) {
+      const meta = methodMeta.get(fn);
+      if (meta) {
+        routes.push(meta);
+      }
+    }
+  }
+  return routes;
+}
+__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 = class _RadixNode {
+  /**
+   * Creates a new RadixNode.
+   * @param segment - The segment of the path this node represents.
+   */
+  constructor(segment) {
+    __publicField(this, "segment");
+    __publicField(this, "children", []);
+    __publicField(this, "value");
+    __publicField(this, "isParam");
+    __publicField(this, "paramName");
+    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() {
+    __publicField(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
+        };
+      }
+      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);
+      }
+    }
+    for (const child of staticChildren) {
+      if (rest.length === 0) {
+        if (child.value !== void 0 || child.children.length > 0) {
+          return { node: child, params };
+        }
+      }
+      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 };
+        }
+      }
+      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 ?? "");
+    __publicField(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);
+    __publicField(this, "status", 400);
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var _UnauthorizedException = class _UnauthorizedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 401);
+  }
+};
+__name(_UnauthorizedException, "UnauthorizedException");
+var UnauthorizedException = _UnauthorizedException;
+var _PaymentRequiredException = class _PaymentRequiredException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 402);
+  }
+};
+__name(_PaymentRequiredException, "PaymentRequiredException");
+var PaymentRequiredException = _PaymentRequiredException;
+var _ForbiddenException = class _ForbiddenException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 403);
+  }
+};
+__name(_ForbiddenException, "ForbiddenException");
+var ForbiddenException = _ForbiddenException;
+var _NotFoundException = class _NotFoundException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 404);
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var _MethodNotAllowedException = class _MethodNotAllowedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 405);
+  }
+};
+__name(_MethodNotAllowedException, "MethodNotAllowedException");
+var MethodNotAllowedException = _MethodNotAllowedException;
+var _NotAcceptableException = class _NotAcceptableException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 406);
+  }
+};
+__name(_NotAcceptableException, "NotAcceptableException");
+var NotAcceptableException = _NotAcceptableException;
+var _RequestTimeoutException = class _RequestTimeoutException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 408);
+  }
+};
+__name(_RequestTimeoutException, "RequestTimeoutException");
+var RequestTimeoutException = _RequestTimeoutException;
+var _ConflictException = class _ConflictException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 409);
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _UpgradeRequiredException = class _UpgradeRequiredException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 426);
+  }
+};
+__name(_UpgradeRequiredException, "UpgradeRequiredException");
+var UpgradeRequiredException = _UpgradeRequiredException;
+var _TooManyRequestsException = class _TooManyRequestsException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 429);
+  }
+};
+__name(_TooManyRequestsException, "TooManyRequestsException");
+var TooManyRequestsException = _TooManyRequestsException;
+var _InternalServerException = class _InternalServerException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 500);
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _NotImplementedException = class _NotImplementedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 501);
+  }
+};
+__name(_NotImplementedException, "NotImplementedException");
+var NotImplementedException = _NotImplementedException;
+var _BadGatewayException = class _BadGatewayException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 502);
+  }
+};
+__name(_BadGatewayException, "BadGatewayException");
+var BadGatewayException = _BadGatewayException;
+var _ServiceUnavailableException = class _ServiceUnavailableException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 503);
+  }
+};
+__name(_ServiceUnavailableException, "ServiceUnavailableException");
+var ServiceUnavailableException = _ServiceUnavailableException;
+var _GatewayTimeoutException = class _GatewayTimeoutException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 504);
+  }
+};
+__name(_GatewayTimeoutException, "GatewayTimeoutException");
+var GatewayTimeoutException = _GatewayTimeoutException;
+var _HttpVersionNotSupportedException = class _HttpVersionNotSupportedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 505);
+  }
+};
+__name(_HttpVersionNotSupportedException, "HttpVersionNotSupportedException");
+var HttpVersionNotSupportedException = _HttpVersionNotSupportedException;
+var _VariantAlsoNegotiatesException = class _VariantAlsoNegotiatesException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 506);
+  }
+};
+__name(_VariantAlsoNegotiatesException, "VariantAlsoNegotiatesException");
+var VariantAlsoNegotiatesException = _VariantAlsoNegotiatesException;
+var _InsufficientStorageException = class _InsufficientStorageException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 507);
+  }
+};
+__name(_InsufficientStorageException, "InsufficientStorageException");
+var InsufficientStorageException = _InsufficientStorageException;
+var _LoopDetectedException = class _LoopDetectedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 508);
+  }
+};
+__name(_LoopDetectedException, "LoopDetectedException");
+var LoopDetectedException = _LoopDetectedException;
+var _NotExtendedException = class _NotExtendedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 510);
+  }
+};
+__name(_NotExtendedException, "NotExtendedException");
+var NotExtendedException = _NotExtendedException;
+var _NetworkAuthenticationRequiredException = class _NetworkAuthenticationRequiredException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 511);
+  }
+};
+__name(_NetworkAuthenticationRequiredException, "NetworkAuthenticationRequiredException");
+var NetworkAuthenticationRequiredException = _NetworkAuthenticationRequiredException;
+var _NetworkConnectTimeoutException = class _NetworkConnectTimeoutException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(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;
+    __publicField(this, "context", RootInjector.createScope());
+    __publicField(this, "params", {});
+    __publicField(this, "query");
+    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,
+    event,
+    payload
+  };
+}
+__name(createRendererEventMessage, "createRendererEventMessage");
+function isRendererEventMessage(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const possibleMessage = value;
+  return possibleMessage.type === RENDERER_EVENT_TYPE && typeof possibleMessage.event === "string";
+}
+__name(isRendererEventMessage, "isRendererEventMessage");
+
+// src/internal/router.ts
+var _Router_decorators, _init;
+_Router_decorators = [Injectable({ lifetime: "singleton" })];
+var _Router = class _Router {
+  constructor() {
+    __publicField(this, "routes", new RadixTree());
+    __publicField(this, "rootMiddlewares", []);
+    __publicField(this, "lazyRoutes", /* @__PURE__ */ new Map());
+    __publicField(this, "lazyLoadLock", Promise.resolve());
+  }
+  // -------------------------------------------------------------------------
+  // 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;
+      }
+    }
+  }
+  loadLazyModule(prefix, entry) {
+    const task = this.lazyLoadLock.then(async () => {
+      const t0 = performance.now();
+      InjectorExplorer.beginAccumulate();
+      await entry.load?.();
+      entry.load = null;
+      await InjectorExplorer.flushAccumulated(entry.guards, entry.middlewares, prefix);
+      entry.loaded = true;
+      entry.loading = null;
+      Logger.info(`Lazy-loaded module for prefix {${prefix}} in ${Math.round(performance.now() - t0)}ms`);
+    });
+    this.lazyLoadLock = task;
+    return task;
+  }
+  // -------------------------------------------------------------------------
+  // 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, query } = 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, query };
+  }
+  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);
+    }
+  }
+};
+_init = __decoratorStart(null);
+_Router = __decorateElement(_init, 0, "Router", _Router_decorators, _Router);
+__name(_Router, "Router");
+__runInitializers(_init, 1, _Router);
+var Router = _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 {
+var _WindowManager_decorators, _init2;
+_WindowManager_decorators = [Injectable({ lifetime: "singleton" })];
+var _WindowManager = class _WindowManager {
   constructor() {
-    this._windows = /* @__PURE__ */ new Map();
+    __publicField(this, "_windows", /* @__PURE__ */ new Map());
+    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+    __publicField(this, "_mainWindowId");
   }
   // -------------------------------------------------------------------------
   // Creation
@@ -1425,18 +1515,24 @@ var WindowManager = class {
    * win.loadFile('index.html');
    */
   async createSplash(options = {}) {
-    const { animationDuration = 600, ...bwOptions } = options;
+    const {
+      animationDuration = 10,
+      expandToWorkArea = true,
+      ...bwOptions
+    } = options;
     const win = new import_main.BrowserWindow({
       width: 600,
       height: 600,
       center: true,
-      frame: false,
       show: true,
       ...bwOptions
     });
     this._register(win, true);
     Logger.log(`[WindowManager] Splash window #${win.id} created`);
-    await this._expandToWorkArea(win, animationDuration);
+    if (expandToWorkArea) {
+      await (() => new Promise((r) => setTimeout(r, 500)))();
+      await this._expandToWorkArea(win, animationDuration);
+    }
     return win;
   }
   // -------------------------------------------------------------------------
@@ -1495,10 +1591,24 @@ var WindowManager = class {
    */
   broadcast(channel, ...args) {
     for (const win of this._windows.values()) {
-      if (!win.isDestroyed()) win.webContents.send(channel, ...args);
+      if (!win.isDestroyed()) {
+        win.webContents.send(channel, ...args);
+      }
     }
   }
   // -------------------------------------------------------------------------
+  // 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) {
@@ -1506,10 +1616,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;
+      if (this._mainWindowId === win.id) {
+        this._mainWindowId = void 0;
+      }
       Logger.log(`[WindowManager] Window #${win.id} closed`);
+      this._emit("closed", win);
     });
   }
   /**
@@ -1519,36 +1635,34 @@ var WindowManager = class {
    */
   _expandToWorkArea(win, animationDuration) {
     return new Promise((resolve) => {
-      const { x, y, width, height } = import_main.screen.getPrimaryDisplay().workArea;
-      win.setBounds({ x, y, width, height }, true);
+      win.maximize();
       let resolved = false;
       const done = /* @__PURE__ */ __name(() => {
-        if (resolved) return;
+        if (resolved) {
+          return;
+        }
         resolved = true;
         win.removeListener("resize", done);
         resolve();
       }, "done");
       win.once("resize", done);
-      setTimeout(done, animationDuration + 100);
+      setTimeout(done, animationDuration);
     });
   }
 };
-__name(WindowManager, "WindowManager");
-WindowManager = __decorateClass([
-  Injectable({ lifetime: "singleton" })
-], WindowManager);
-
-// src/internal/app.ts
-init_request();
-init_router();
+_init2 = __decoratorStart(null);
+_WindowManager = __decorateElement(_init2, 0, "WindowManager", _WindowManager_decorators, _WindowManager);
+__name(_WindowManager, "WindowManager");
+__runInitializers(_init2, 1, _WindowManager);
+var WindowManager = _WindowManager;
 
 // src/internal/socket.ts
-init_injectable_decorator();
 init_logger();
-init_request();
-var NoxSocket = class {
+var _NoxSocket_decorators, _init3;
+_NoxSocket_decorators = [Injectable({ lifetime: "singleton" })];
+var _NoxSocket = class _NoxSocket {
   constructor() {
-    this.channels = /* @__PURE__ */ new Map();
+    __publicField(this, "channels", /* @__PURE__ */ new Map());
   }
   register(senderId, requestChannel, socketChannel) {
     this.channels.set(senderId, { request: requestChannel, socket: socketChannel });
@@ -1568,7 +1682,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) {
@@ -1577,40 +1690,46 @@ 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");
-NoxSocket = __decorateClass([
-  Injectable({ lifetime: "singleton" })
-], NoxSocket);
+_init3 = __decoratorStart(null);
+_NoxSocket = __decorateElement(_init3, 0, "NoxSocket", _NoxSocket_decorators, _NoxSocket);
+__name(_NoxSocket, "NoxSocket");
+__runInitializers(_init3, 1, _NoxSocket);
+var NoxSocket = _NoxSocket;
 
 // src/internal/app.ts
-var NoxApp = class {
-  constructor() {
-    this.router = inject(Router);
-    this.socket = inject(NoxSocket);
-    this.windowManager = inject(WindowManager);
+var _NoxApp_decorators, _init4;
+_NoxApp_decorators = [Injectable({ lifetime: "singleton", deps: [Router, NoxSocket, WindowManager] })];
+var _NoxApp = class _NoxApp {
+  constructor(router, socket, windowManager) {
+    this.router = router;
+    this.socket = socket;
+    this.windowManager = windowManager;
+    __publicField(this, "appService");
     // -------------------------------------------------------------------------
     // IPC
     // -------------------------------------------------------------------------
-    this.onRendererMessage = /* @__PURE__ */ __name(async (event) => {
-      const { senderId, requestId, path: path2, method, body } = event.data;
+    __publicField(this, "onRendererMessage", /* @__PURE__ */ __name(async (event) => {
+      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) {
@@ -1622,7 +1741,7 @@ var NoxApp = class {
         };
         channels.request.port1.postMessage(response);
       }
-    }, "onRendererMessage");
+    }, "onRendererMessage"));
   }
   // -------------------------------------------------------------------------
   // Initialisation
@@ -1661,7 +1780,7 @@ var NoxApp = class {
   async load(importFns) {
     InjectorExplorer.beginAccumulate();
     await Promise.all(importFns.map((fn) => fn()));
-    InjectorExplorer.flushAccumulated();
+    await InjectorExplorer.flushAccumulated();
     return this;
   }
   /**
@@ -1730,27 +1849,44 @@ var NoxApp = class {
     this.socket.unregister(channelSenderId);
   }
 };
-__name(NoxApp, "NoxApp");
-NoxApp = __decorateClass([
-  Injectable({ lifetime: "singleton", deps: [Router, NoxSocket, WindowManager] })
-], NoxApp);
+_init4 = __decoratorStart(null);
+_NoxApp = __decorateElement(_init4, 0, "NoxApp", _NoxApp_decorators, _NoxApp);
+__name(_NoxApp, "NoxApp");
+__runInitializers(_init4, 1, _NoxApp);
+var NoxApp = _NoxApp;
 
 // src/internal/bootstrap.ts
 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) {
@@ -1762,29 +1898,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,
@@ -1838,6 +1998,7 @@ __name(defineRoutes, "defineRoutes");
   inject,
   isAtomicHttpMethod,
   isRendererEventMessage,
+  resetRootInjector,
   token
 });
 /**