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

package/dist/child.mjs

@@ -24,14 +24,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 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;
-};
 
 // src/utils/forward-ref.ts
 function forwardRef(fn) {
@@ -71,326 +63,6 @@ var init_token = __esm({
   }
 });
 
-// src/DI/app-injector.ts
-function keyOf(k) {
-  return k;
-}
-function inject(t) {
-  return RootInjector.resolve(t);
-}
-var _AppInjector, AppInjector, RootInjector;
-var init_app_injector = __esm({
-  "src/DI/app-injector.ts"() {
-    "use strict";
-    init_forward_ref();
-    init_token();
-    __name(keyOf, "keyOf");
-    _AppInjector = class _AppInjector {
-      constructor(name = null) {
-        this.name = name;
-        this.bindings = /* @__PURE__ */ new Map();
-        this.singletons = /* @__PURE__ */ new Map();
-        this.scoped = /* @__PURE__ */ new Map();
-      }
-      /**
-       * Creates a child scope for per-request lifetime resolution.
-       */
-      createScope() {
-        const scope = new _AppInjector();
-        scope.bindings = this.bindings;
-        scope.singletons = this.singletons;
-        return scope;
-      }
-      /**
-       * Registers a binding explicitly.
-       */
-      register(key, implementation, lifetime, deps = []) {
-        const k = keyOf(key);
-        if (!this.bindings.has(k)) {
-          this.bindings.set(k, { lifetime, implementation, deps });
-        }
-      }
-      /**
-       * Resolves a dependency by token or class reference.
-       */
-      resolve(target) {
-        if (target instanceof ForwardReference) {
-          return this._resolveForwardRef(target);
-        }
-        const k = keyOf(target);
-        if (this.singletons.has(k)) {
-          return this.singletons.get(k);
-        }
-        const binding = this.bindings.get(k);
-        if (!binding) {
-          const name = target instanceof Token ? target.description : target.name ?? "unknown";
-          throw new Error(
-            `[Noxus DI] No binding found for "${name}".
-Did you forget to declare it in @Injectable({ deps }) or in bootstrapApplication({ singletons })?`
-          );
-        }
-        switch (binding.lifetime) {
-          case "transient":
-            return this._instantiate(binding);
-          case "scope": {
-            if (this.scoped.has(k)) return this.scoped.get(k);
-            const inst = this._instantiate(binding);
-            this.scoped.set(k, inst);
-            return inst;
-          }
-          case "singleton": {
-            if (this.singletons.has(k)) return this.singletons.get(k);
-            const inst = this._instantiate(binding);
-            this.singletons.set(k, inst);
-            if (binding.instance === void 0) {
-              binding.instance = inst;
-            }
-            return inst;
-          }
-        }
-      }
-      // -------------------------------------------------------------------------
-      _resolveForwardRef(ref) {
-        return new Proxy({}, {
-          get: /* @__PURE__ */ __name((_obj, prop, receiver) => {
-            const realType = ref.forwardRefFn();
-            const instance = this.resolve(realType);
-            const value = Reflect.get(instance, prop, receiver);
-            return typeof value === "function" ? value.bind(instance) : value;
-          }, "get"),
-          set: /* @__PURE__ */ __name((_obj, prop, value, receiver) => {
-            const realType = ref.forwardRefFn();
-            const instance = this.resolve(realType);
-            return Reflect.set(instance, prop, value, receiver);
-          }, "set"),
-          getPrototypeOf: /* @__PURE__ */ __name(() => {
-            const realType = ref.forwardRefFn();
-            return realType.prototype;
-          }, "getPrototypeOf")
-        });
-      }
-      _instantiate(binding) {
-        const resolvedDeps = binding.deps.map((dep) => this.resolve(dep));
-        return new binding.implementation(...resolvedDeps);
-      }
-    };
-    __name(_AppInjector, "AppInjector");
-    AppInjector = _AppInjector;
-    RootInjector = new AppInjector("root");
-    __name(inject, "inject");
-  }
-});
-
-// src/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/utils/logger.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -638,502 +310,11 @@ var init_logger = __esm({
   }
 });
 
-// src/decorators/controller.decorator.ts
-function getControllerMetadata(target) {
-  return controllerMetaMap.get(target);
-}
-var controllerMetaMap;
-var init_controller_decorator = __esm({
-  "src/decorators/controller.decorator.ts"() {
-    "use strict";
-    init_injector_explorer();
-    controllerMetaMap = /* @__PURE__ */ new WeakMap();
-    __name(getControllerMetadata, "getControllerMetadata");
-  }
-});
-
-// 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);
-      }
-      /**
-       * Adds a child node to this node's children.
-       * This method adds a new child node to the list of children for this node.
-       * @param node - The child node to add to this node's children.
-       */
-      addChild(node) {
-        this.children.push(node);
-      }
-    };
-    __name(_RadixNode, "RadixNode");
-    RadixNode = _RadixNode;
-    _RadixTree = class _RadixTree {
-      constructor() {
-        this.root = new RadixNode("");
-      }
-      /**
-       * 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, {});
-      }
-      /**
-       * Recursively searches for a path in the Radix Tree.
-       * This method traverses the tree and searches for the segments of the path, collecting parameters
-       * @param node - The node to start searching from.
-       * @param segments - The segments of the path to search for.
-       * @param params - The parameters collected during the search.
-       * @returns An ISearchResult containing the node and parameters if a match is found, otherwise undefined.
-       */
-      searchRecursive(node, segments, params) {
-        if (segments.length === 0) {
-          if (node.value !== void 0) {
-            return {
-              node,
-              params
-            };
-          }
-          return void 0;
-        }
-        const [segment, ...rest] = segments;
-        for (const child of node.children) {
-          if (child.isParam) {
-            const paramName = child.paramName;
-            const childParams = {
-              ...params,
-              [paramName]: segment ?? ""
-            };
-            if (rest.length === 0) {
-              return {
-                node: child,
-                params: childParams
-              };
-            }
-            const result = this.searchRecursive(child, rest, childParams);
-            if (result)
-              return result;
-          } else if (segment === child.segment) {
-            if (rest.length === 0) {
-              return {
-                node: child,
-                params
-              };
-            }
-            const result = this.searchRecursive(child, rest, params);
-            if (result)
-              return result;
-          }
-        }
-        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/request.ts
-var _Request, Request;
-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;
-  }
-});
-
-// src/internal/router.ts
-var router_exports = {};
-__export(router_exports, {
-  Router: () => Router
-});
-var Router;
-var init_router = __esm({
-  "src/internal/router.ts"() {
-    "use strict";
-    init_controller_decorator();
-    init_injectable_decorator();
-    init_method_decorator();
-    init_injector_explorer();
-    init_logger();
-    init_radix_tree();
-    init_exceptions();
-    init_request();
-    Router = class {
-      constructor() {
-        this.routes = new RadixTree();
-        this.rootMiddlewares = [];
-        this.lazyRoutes = /* @__PURE__ */ new Map();
-      }
-      // -------------------------------------------------------------------------
-      // Registration
-      // -------------------------------------------------------------------------
-      registerController(controllerClass, pathPrefix, routeGuards = [], routeMiddlewares = []) {
-        const meta = getControllerMetadata(controllerClass);
-        if (!meta) {
-          throw new Error(`[Noxus] Missing @Controller decorator on ${controllerClass.name}`);
-        }
-        const routeMeta = getRouteMetadata(controllerClass);
-        for (const def of routeMeta) {
-          const fullPath = `${pathPrefix}/${def.path}`.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
-          const guards = [.../* @__PURE__ */ new Set([...routeGuards, ...def.guards])];
-          const middlewares = [.../* @__PURE__ */ new Set([...routeMiddlewares, ...def.middlewares])];
-          const routeDef = {
-            method: def.method,
-            path: fullPath,
-            controller: controllerClass,
-            handler: def.handler,
-            guards,
-            middlewares
-          };
-          this.routes.insert(fullPath + "/" + def.method, routeDef);
-          const guardInfo = guards.length ? `<${guards.map((g) => g.name).join("|")}>` : "";
-          Logger.log(`Mapped {${def.method} /${fullPath}}${guardInfo} route`);
-        }
-        const ctrlGuardInfo = routeGuards.length ? `<${routeGuards.map((g) => g.name).join("|")}>` : "";
-        Logger.log(`Mapped ${controllerClass.name}${ctrlGuardInfo} controller's routes`);
-        return this;
-      }
-      registerLazyRoute(pathPrefix, load, guards = [], middlewares = []) {
-        const normalized = pathPrefix.replace(/^\/+|\/+$/g, "");
-        this.lazyRoutes.set(normalized, { load, guards, middlewares, loading: null, loaded: false });
-        Logger.log(`Registered lazy route prefix {${normalized}}`);
-        return this;
-      }
-      defineRootMiddleware(middleware) {
-        this.rootMiddlewares.push(middleware);
-        return this;
-      }
-      // -------------------------------------------------------------------------
-      // Request handling
-      // -------------------------------------------------------------------------
-      async handle(request) {
-        return request.method === "BATCH" ? this.handleBatch(request) : this.handleAtomic(request);
-      }
-      async handleAtomic(request) {
-        Logger.comment(`>     ${request.method} /${request.path}`);
-        const t0 = performance.now();
-        const response = { requestId: request.id, status: 200, body: null };
-        let isCritical = false;
-        try {
-          const routeDef = await this.findRoute(request);
-          await this.resolveController(request, response, routeDef);
-          if (response.status >= 400) throw new ResponseException(response.status, response.error);
-        } catch (error) {
-          this.fillErrorResponse(response, error, (c) => {
-            isCritical = c;
-          });
-        } finally {
-          this.logResponse(request, response, performance.now() - t0, isCritical);
-          return response;
-        }
-      }
-      async handleBatch(request) {
-        Logger.comment(`>     ${request.method} /${request.path}`);
-        const t0 = performance.now();
-        const response = {
-          requestId: request.id,
-          status: 200,
-          body: { responses: [] }
-        };
-        let isCritical = false;
-        try {
-          const payload = this.normalizeBatchPayload(request.body);
-          response.body.responses = await Promise.all(
-            payload.requests.map((item, i) => {
-              const id = item.requestId ?? `${request.id}:${i}`;
-              return this.handleAtomic(new Request(request.event, request.senderId, id, item.method, item.path, item.body));
-            })
-          );
-        } catch (error) {
-          this.fillErrorResponse(response, error, (c) => {
-            isCritical = c;
-          });
-        } finally {
-          this.logResponse(request, response, performance.now() - t0, isCritical);
-          return response;
-        }
-      }
-      // -------------------------------------------------------------------------
-      // Route resolution
-      // -------------------------------------------------------------------------
-      tryFindRoute(request) {
-        const matched = this.routes.search(request.path);
-        if (!matched?.node || matched.node.children.length === 0) return void 0;
-        return matched.node.findExactChild(request.method)?.value;
-      }
-      async findRoute(request) {
-        const direct = this.tryFindRoute(request);
-        if (direct) return direct;
-        await this.tryLoadLazyRoute(request.path);
-        const afterLazy = this.tryFindRoute(request);
-        if (afterLazy) return afterLazy;
-        throw new NotFoundException(`No route matches ${request.method} ${request.path}`);
-      }
-      async tryLoadLazyRoute(requestPath) {
-        const firstSegment = requestPath.replace(/^\/+/, "").split("/")[0] ?? "";
-        for (const [prefix, entry] of this.lazyRoutes) {
-          if (entry.loaded) continue;
-          const normalized = requestPath.replace(/^\/+/, "");
-          if (normalized === prefix || normalized.startsWith(prefix + "/") || firstSegment === prefix) {
-            if (!entry.loading) entry.loading = this.loadLazyModule(prefix, entry);
-            await entry.loading;
-            return;
-          }
-        }
-      }
-      async loadLazyModule(prefix, entry) {
-        const t0 = performance.now();
-        InjectorExplorer.beginAccumulate();
-        await entry.load?.();
-        entry.loading = null;
-        entry.load = null;
-        InjectorExplorer.flushAccumulated(entry.guards, entry.middlewares, prefix);
-        entry.loaded = true;
-        Logger.info(`Lazy-loaded module for prefix {${prefix}} in ${Math.round(performance.now() - t0)}ms`);
-      }
-      // -------------------------------------------------------------------------
-      // Pipeline
-      // -------------------------------------------------------------------------
-      async resolveController(request, response, routeDef) {
-        const instance = request.context.resolve(routeDef.controller);
-        Object.assign(request.params, this.extractParams(request.path, routeDef.path));
-        await this.runPipeline(request, response, routeDef, instance);
-      }
-      async runPipeline(request, response, routeDef, controllerInstance) {
-        const middlewares = [.../* @__PURE__ */ new Set([...this.rootMiddlewares, ...routeDef.middlewares])];
-        const mwMax = middlewares.length - 1;
-        const guardMax = mwMax + routeDef.guards.length;
-        let index = -1;
-        const dispatch = /* @__PURE__ */ __name(async (i) => {
-          if (i <= index) throw new Error("next() called multiple times");
-          index = i;
-          if (i <= mwMax) {
-            await this.runMiddleware(request, response, dispatch.bind(null, i + 1), middlewares[i]);
-            if (response.status >= 400) throw new ResponseException(response.status, response.error);
-            return;
-          }
-          if (i <= guardMax) {
-            await this.runGuard(request, routeDef.guards[i - middlewares.length]);
-            await dispatch(i + 1);
-            return;
-          }
-          const action = controllerInstance[routeDef.handler];
-          response.body = await action.call(controllerInstance, request, response);
-          if (response.body === void 0) response.body = {};
-        }, "dispatch");
-        await dispatch(0);
-      }
-      async runMiddleware(request, response, next, middleware) {
-        await middleware(request, response, next);
-      }
-      async runGuard(request, guard) {
-        if (!await guard(request)) {
-          throw new UnauthorizedException(`Unauthorized for ${request.method} ${request.path}`);
-        }
-      }
-      // -------------------------------------------------------------------------
-      // Utilities
-      // -------------------------------------------------------------------------
-      extractParams(actual, template) {
-        const aParts = actual.split("/");
-        const tParts = template.split("/");
-        const params = {};
-        tParts.forEach((part, i) => {
-          if (part.startsWith(":")) params[part.slice(1)] = aParts[i] ?? "";
-        });
-        return params;
-      }
-      normalizeBatchPayload(body) {
-        if (body === null || typeof body !== "object") {
-          throw new BadRequestException("Batch payload must be an object containing a requests array.");
-        }
-        const { requests } = body;
-        if (!Array.isArray(requests)) throw new BadRequestException("Batch payload must define a requests array.");
-        return { requests: requests.map((e, i) => this.normalizeBatchItem(e, i)) };
-      }
-      normalizeBatchItem(entry, index) {
-        if (entry === null || typeof entry !== "object") throw new BadRequestException(`Batch request at index ${index} must be an object.`);
-        const { requestId, path: path2, method, body } = entry;
-        if (requestId !== void 0 && typeof requestId !== "string") throw new BadRequestException(`Batch request at index ${index} has an invalid requestId.`);
-        if (typeof path2 !== "string" || !path2.length) throw new BadRequestException(`Batch request at index ${index} must define a non-empty path.`);
-        if (typeof method !== "string") throw new BadRequestException(`Batch request at index ${index} must define an HTTP method.`);
-        const normalized = method.toUpperCase();
-        if (!isAtomicHttpMethod(normalized)) throw new BadRequestException(`Batch request at index ${index} uses unsupported method ${method}.`);
-        return { requestId, path: path2, method: normalized, body };
-      }
-      fillErrorResponse(response, error, setCritical) {
-        response.body = void 0;
-        if (error instanceof ResponseException) {
-          response.status = error.status;
-          response.error = error.message;
-          response.stack = error.stack;
-        } else if (error instanceof Error) {
-          setCritical(true);
-          response.status = 500;
-          response.error = error.message || "Internal Server Error";
-          response.stack = error.stack;
-        } else {
-          setCritical(true);
-          response.status = 500;
-          response.error = "Unknown error occurred";
-        }
-      }
-      logResponse(request, response, ms, isCritical) {
-        const msg = `< ${response.status} ${request.method} /${request.path} ${Logger.colors.yellow}${Math.round(ms)}ms${Logger.colors.initial}`;
-        if (response.status < 400) Logger.log(msg);
-        else if (response.status < 500) Logger.warn(msg);
-        else isCritical ? Logger.critical(msg) : Logger.error(msg);
-        if (response.error) {
-          isCritical ? Logger.critical(response.error) : Logger.error(response.error);
-          if (response.stack) Logger.errorStack(response.stack);
-        }
-      }
-    };
-    __name(Router, "Router");
-    Router = __decorateClass([
-      Injectable({ lifetime: "singleton" })
-    ], Router);
-  }
-});
-
 // src/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"() {
@@ -1144,6 +325,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);
@@ -1169,16 +357,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
@@ -1189,8 +398,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);
@@ -1202,9 +418,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}`);
           }
@@ -1215,10 +437,8 @@ var init_injector_explorer = __esm({
         if (reg.lifetime === "singleton") {
           RootInjector.resolve(reg.key);
         }
-        if (reg.isController) {
-          const { Router: Router2 } = (init_router(), __toCommonJS(router_exports));
-          const router = RootInjector.resolve(Router2);
-          router.registerController(reg.implementation);
+        if (reg.isController && _InjectorExplorer.controllerRegistrar) {
+          _InjectorExplorer.controllerRegistrar(reg.implementation, "", [], []);
         }
       }
     };
@@ -1226,11 +446,339 @@ var init_injector_explorer = __esm({
     _InjectorExplorer.pending = [];
     _InjectorExplorer.processed = false;
     _InjectorExplorer.accumulating = false;
+    _InjectorExplorer.loadingLock = Promise.resolve();
+    _InjectorExplorer.controllerRegistrar = null;
     InjectorExplorer = _InjectorExplorer;
   }
 });
 
+// src/DI/app-injector.ts
+function keyOf(k) {
+  return k;
+}
+function resetRootInjector() {
+  RootInjector.bindings.clear();
+  RootInjector.singletons.clear();
+  RootInjector.scoped.clear();
+  const { InjectorExplorer: InjectorExplorer2 } = (init_injector_explorer(), __toCommonJS(injector_explorer_exports));
+  InjectorExplorer2.reset();
+}
+function inject(t) {
+  return RootInjector.resolve(t);
+}
+var _AppInjector, AppInjector, RootInjector;
+var init_app_injector = __esm({
+  "src/DI/app-injector.ts"() {
+    "use strict";
+    init_forward_ref();
+    init_token();
+    __name(keyOf, "keyOf");
+    _AppInjector = class _AppInjector {
+      constructor(name = null) {
+        this.name = name;
+        this.bindings = /* @__PURE__ */ new Map();
+        this.singletons = /* @__PURE__ */ new Map();
+        this.scoped = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Creates a child scope for per-request lifetime resolution.
+       */
+      createScope() {
+        const scope = new _AppInjector();
+        scope.bindings = this.bindings;
+        scope.singletons = this.singletons;
+        return scope;
+      }
+      /**
+       * Registers a binding explicitly.
+       */
+      register(key, implementation, lifetime, deps = []) {
+        const k = keyOf(key);
+        if (!this.bindings.has(k)) {
+          this.bindings.set(k, { lifetime, implementation, deps });
+        }
+      }
+      /**
+       * Resolves a dependency by token or class reference.
+       */
+      resolve(target) {
+        if (target instanceof ForwardReference) {
+          return this._resolveForwardRef(target);
+        }
+        const k = keyOf(target);
+        if (this.singletons.has(k)) {
+          return this.singletons.get(k);
+        }
+        const binding = this.bindings.get(k);
+        if (!binding) {
+          const name = target instanceof Token ? target.description : target.name ?? "unknown";
+          throw new Error(
+            `[Noxus DI] No binding found for "${name}".
+Did you forget to declare it in @Injectable({ deps }) or in bootstrapApplication({ singletons })?`
+          );
+        }
+        switch (binding.lifetime) {
+          case "transient":
+            return this._instantiate(binding);
+          case "scope": {
+            if (this.scoped.has(k)) return this.scoped.get(k);
+            const inst = this._instantiate(binding);
+            this.scoped.set(k, inst);
+            return inst;
+          }
+          case "singleton": {
+            if (this.singletons.has(k)) return this.singletons.get(k);
+            const inst = this._instantiate(binding);
+            this.singletons.set(k, inst);
+            if (binding.instance === void 0) {
+              binding.instance = inst;
+            }
+            return inst;
+          }
+        }
+      }
+      // -------------------------------------------------------------------------
+      _resolveForwardRef(ref) {
+        let resolved;
+        return new Proxy({}, {
+          get: /* @__PURE__ */ __name((_obj, prop, receiver) => {
+            resolved ?? (resolved = this.resolve(ref.forwardRefFn()));
+            const value = Reflect.get(resolved, prop, receiver);
+            return typeof value === "function" ? value.bind(resolved) : value;
+          }, "get"),
+          set: /* @__PURE__ */ __name((_obj, prop, value, receiver) => {
+            resolved ?? (resolved = this.resolve(ref.forwardRefFn()));
+            return Reflect.set(resolved, prop, value, receiver);
+          }, "set"),
+          getPrototypeOf: /* @__PURE__ */ __name(() => {
+            resolved ?? (resolved = this.resolve(ref.forwardRefFn()));
+            return Object.getPrototypeOf(resolved);
+          }, "getPrototypeOf")
+        });
+      }
+      _instantiate(binding) {
+        const resolvedDeps = binding.deps.map((dep) => this.resolve(dep));
+        return new binding.implementation(...resolvedDeps);
+      }
+    };
+    __name(_AppInjector, "AppInjector");
+    AppInjector = _AppInjector;
+    RootInjector = new AppInjector("root");
+    __name(resetRootInjector, "resetRootInjector");
+    __name(inject, "inject");
+  }
+});
+
+// src/non-electron-process.ts
+init_app_injector();
+
+// src/internal/exceptions.ts
+var _ResponseException = class _ResponseException extends Error {
+  constructor(statusOrMessage, message) {
+    let statusCode;
+    if (typeof statusOrMessage === "number") {
+      statusCode = statusOrMessage;
+    } else if (typeof statusOrMessage === "string") {
+      message = statusOrMessage;
+    }
+    super(message ?? "");
+    this.status = 0;
+    if (statusCode !== void 0) {
+      this.status = statusCode;
+    }
+    this.name = this.constructor.name.replace(/([A-Z])/g, " $1");
+  }
+};
+__name(_ResponseException, "ResponseException");
+var ResponseException = _ResponseException;
+var _BadRequestException = class _BadRequestException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 400;
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var _UnauthorizedException = class _UnauthorizedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 401;
+  }
+};
+__name(_UnauthorizedException, "UnauthorizedException");
+var UnauthorizedException = _UnauthorizedException;
+var _PaymentRequiredException = class _PaymentRequiredException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 402;
+  }
+};
+__name(_PaymentRequiredException, "PaymentRequiredException");
+var PaymentRequiredException = _PaymentRequiredException;
+var _ForbiddenException = class _ForbiddenException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 403;
+  }
+};
+__name(_ForbiddenException, "ForbiddenException");
+var ForbiddenException = _ForbiddenException;
+var _NotFoundException = class _NotFoundException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 404;
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var _MethodNotAllowedException = class _MethodNotAllowedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 405;
+  }
+};
+__name(_MethodNotAllowedException, "MethodNotAllowedException");
+var MethodNotAllowedException = _MethodNotAllowedException;
+var _NotAcceptableException = class _NotAcceptableException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 406;
+  }
+};
+__name(_NotAcceptableException, "NotAcceptableException");
+var NotAcceptableException = _NotAcceptableException;
+var _RequestTimeoutException = class _RequestTimeoutException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 408;
+  }
+};
+__name(_RequestTimeoutException, "RequestTimeoutException");
+var RequestTimeoutException = _RequestTimeoutException;
+var _ConflictException = class _ConflictException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 409;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _UpgradeRequiredException = class _UpgradeRequiredException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 426;
+  }
+};
+__name(_UpgradeRequiredException, "UpgradeRequiredException");
+var UpgradeRequiredException = _UpgradeRequiredException;
+var _TooManyRequestsException = class _TooManyRequestsException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 429;
+  }
+};
+__name(_TooManyRequestsException, "TooManyRequestsException");
+var TooManyRequestsException = _TooManyRequestsException;
+var _InternalServerException = class _InternalServerException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 500;
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _NotImplementedException = class _NotImplementedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 501;
+  }
+};
+__name(_NotImplementedException, "NotImplementedException");
+var NotImplementedException = _NotImplementedException;
+var _BadGatewayException = class _BadGatewayException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 502;
+  }
+};
+__name(_BadGatewayException, "BadGatewayException");
+var BadGatewayException = _BadGatewayException;
+var _ServiceUnavailableException = class _ServiceUnavailableException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 503;
+  }
+};
+__name(_ServiceUnavailableException, "ServiceUnavailableException");
+var ServiceUnavailableException = _ServiceUnavailableException;
+var _GatewayTimeoutException = class _GatewayTimeoutException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 504;
+  }
+};
+__name(_GatewayTimeoutException, "GatewayTimeoutException");
+var GatewayTimeoutException = _GatewayTimeoutException;
+var _HttpVersionNotSupportedException = class _HttpVersionNotSupportedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 505;
+  }
+};
+__name(_HttpVersionNotSupportedException, "HttpVersionNotSupportedException");
+var HttpVersionNotSupportedException = _HttpVersionNotSupportedException;
+var _VariantAlsoNegotiatesException = class _VariantAlsoNegotiatesException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 506;
+  }
+};
+__name(_VariantAlsoNegotiatesException, "VariantAlsoNegotiatesException");
+var VariantAlsoNegotiatesException = _VariantAlsoNegotiatesException;
+var _InsufficientStorageException = class _InsufficientStorageException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 507;
+  }
+};
+__name(_InsufficientStorageException, "InsufficientStorageException");
+var InsufficientStorageException = _InsufficientStorageException;
+var _LoopDetectedException = class _LoopDetectedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 508;
+  }
+};
+__name(_LoopDetectedException, "LoopDetectedException");
+var LoopDetectedException = _LoopDetectedException;
+var _NotExtendedException = class _NotExtendedException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 510;
+  }
+};
+__name(_NotExtendedException, "NotExtendedException");
+var NotExtendedException = _NotExtendedException;
+var _NetworkAuthenticationRequiredException = class _NetworkAuthenticationRequiredException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 511;
+  }
+};
+__name(_NetworkAuthenticationRequiredException, "NetworkAuthenticationRequiredException");
+var NetworkAuthenticationRequiredException = _NetworkAuthenticationRequiredException;
+var _NetworkConnectTimeoutException = class _NetworkConnectTimeoutException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    this.status = 599;
+  }
+};
+__name(_NetworkConnectTimeoutException, "NetworkConnectTimeoutException");
+var NetworkConnectTimeoutException = _NetworkConnectTimeoutException;
+
 // src/decorators/injectable.decorator.ts
+init_injector_explorer();
+init_token();
 function Injectable(options = {}) {
   const { lifetime = "scope", deps = [] } = options;
   return (target) => {
@@ -1247,19 +795,9 @@ function Injectable(options = {}) {
     });
   };
 }
-var init_injectable_decorator = __esm({
-  "src/decorators/injectable.decorator.ts"() {
-    "use strict";
-    init_injector_explorer();
-    init_token();
-    __name(Injectable, "Injectable");
-  }
-});
+__name(Injectable, "Injectable");
 
 // src/non-electron-process.ts
-init_app_injector();
-init_exceptions();
-init_injectable_decorator();
 init_logger();
 init_forward_ref();
 export {
@@ -1294,7 +832,8 @@ export {
   UpgradeRequiredException,
   VariantAlsoNegotiatesException,
   forwardRef,
-  inject
+  inject,
+  resetRootInjector
 };
 /**
  * @copyright 2025 NoxFly