@noxfly/noxus 2.4.0 → 3.0.0-dev.0

package/dist/renderer.mjs

@@ -4,72 +4,44 @@
  * @author NoxFly
  */
 var __defProp = Object.defineProperty;
-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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/request.ts
-import "reflect-metadata";
-
-// src/DI/app-injector.ts
-import "reflect-metadata";
-
-// src/decorators/inject.decorator.ts
-import "reflect-metadata";
-var INJECT_METADATA_KEY = "custom:inject";
-
-// src/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 _InternalServerException = class _InternalServerException extends ResponseException {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 500);
-  }
-};
-__name(_InternalServerException, "InternalServerException");
-var InternalServerException = _InternalServerException;
 
 // src/utils/forward-ref.ts
 var _ForwardReference = class _ForwardReference {
   constructor(forwardRefFn) {
-    __publicField(this, "forwardRefFn");
     this.forwardRefFn = forwardRefFn;
   }
 };
 __name(_ForwardReference, "ForwardReference");
 var ForwardReference = _ForwardReference;
 
+// src/DI/token.ts
+var _Token = class _Token {
+  constructor(target) {
+    this.target = target;
+    this.description = typeof target === "string" ? target : target.name;
+  }
+  toString() {
+    return `Token(${this.description})`;
+  }
+};
+__name(_Token, "Token");
+var Token = _Token;
+
 // src/DI/app-injector.ts
+function keyOf(k) {
+  return k;
+}
+__name(keyOf, "keyOf");
 var _AppInjector = class _AppInjector {
   constructor(name = null) {
-    __publicField(this, "name");
-    __publicField(this, "bindings", /* @__PURE__ */ new Map());
-    __publicField(this, "singletons", /* @__PURE__ */ new Map());
-    __publicField(this, "scoped", /* @__PURE__ */ new Map());
     this.name = name;
+    this.bindings = /* @__PURE__ */ new Map();
+    this.singletons = /* @__PURE__ */ new Map();
+    this.scoped = /* @__PURE__ */ new Map();
   }
   /**
-   * Typically used to create a dependency injection scope
-   * at the "scope" level (i.e., per-request lifetime).
-   *
-   * SHOULD NOT BE USED by anything else than the framework itself.
+   * Creates a child scope for per-request lifetime resolution.
    */
   createScope() {
     const scope = new _AppInjector();
@@ -78,70 +50,73 @@ var _AppInjector = class _AppInjector {
     return scope;
   }
   /**
-   * Called when resolving a dependency,
-   * i.e., retrieving the instance of a given class.
+   * 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 new Proxy({}, {
-        get: /* @__PURE__ */ __name((obj, prop, receiver) => {
-          const realType = target.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 = target.forwardRefFn();
-          const instance = this.resolve(realType);
-          return Reflect.set(instance, prop, value, receiver);
-        }, "set"),
-        getPrototypeOf: /* @__PURE__ */ __name(() => {
-          const realType = target.forwardRefFn();
-          return realType.prototype;
-        }, "getPrototypeOf")
-      });
+      return this._resolveForwardRef(target);
     }
-    const binding = this.bindings.get(target);
+    const k = keyOf(target);
+    const binding = this.bindings.get(k);
     if (!binding) {
-      if (target === void 0) {
-        throw new InternalServerException("Failed to resolve a dependency injection : Undefined target type.\nThis might be caused by a circular dependency.");
-      }
-      const name = target.name || "unknown";
-      throw new InternalServerException(`Failed to resolve a dependency injection : No binding for type ${name}.
-Did you forget to use @Injectable() decorator ?`);
+      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.implementation);
+        return this._instantiate(binding);
       case "scope": {
-        if (this.scoped.has(target)) {
-          return this.scoped.get(target);
-        }
-        const instance = this.instantiate(binding.implementation);
-        this.scoped.set(target, instance);
-        return instance;
+        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 (binding.instance === void 0 && this.name === "root") {
-          binding.instance = this.instantiate(binding.implementation);
-          this.singletons.set(target, binding.instance);
+        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 binding.instance;
+        return inst;
       }
     }
   }
-  /**
-   * Instantiates a class, resolving its dependencies.
-   */
-  instantiate(target) {
-    const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
-    const injectParams = Reflect.getMetadata(INJECT_METADATA_KEY, target) || [];
-    const params = paramTypes.map((paramType, index) => {
-      const overrideToken = injectParams[index];
-      const actualToken = overrideToken !== void 0 ? overrideToken : paramType;
-      return this.resolve(actualToken);
+  // -------------------------------------------------------------------------
+  _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")
     });
-    return new target(...params);
+  }
+  _instantiate(binding) {
+    const resolvedDeps = binding.deps.map((dep) => this.resolve(dep));
+    return new binding.implementation(...resolvedDeps);
   }
 };
 __name(_AppInjector, "AppInjector");
@@ -151,20 +126,14 @@ var RootInjector = new AppInjector("root");
 // src/request.ts
 var _Request = class _Request {
   constructor(event, senderId, id, method, path, body) {
-    __publicField(this, "event");
-    __publicField(this, "senderId");
-    __publicField(this, "id");
-    __publicField(this, "method");
-    __publicField(this, "path");
-    __publicField(this, "body");
-    __publicField(this, "context", RootInjector.createScope());
-    __publicField(this, "params", {});
     this.event = event;
     this.senderId = senderId;
     this.id = id;
     this.method = method;
     this.path = path;
     this.body = body;
+    this.context = RootInjector.createScope();
+    this.params = {};
     this.path = path.replace(/^\/|\/$/g, "");
   }
 };
@@ -188,10 +157,56 @@ function isRendererEventMessage(value) {
 }
 __name(isRendererEventMessage, "isRendererEventMessage");
 
+// src/preload-bridge.ts
+import { contextBridge, ipcRenderer } from "electron/renderer";
+var DEFAULT_EXPOSE_NAME = "noxus";
+var DEFAULT_INIT_EVENT = "init-port";
+var DEFAULT_REQUEST_CHANNEL = "gimme-my-port";
+var DEFAULT_RESPONSE_CHANNEL = "port";
+function exposeNoxusBridge(options = {}) {
+  const {
+    exposeAs = DEFAULT_EXPOSE_NAME,
+    initMessageType = DEFAULT_INIT_EVENT,
+    requestChannel = DEFAULT_REQUEST_CHANNEL,
+    responseChannel = DEFAULT_RESPONSE_CHANNEL,
+    targetWindow = window
+  } = options;
+  const api = {
+    requestPort: /* @__PURE__ */ __name(() => {
+      ipcRenderer.send(requestChannel);
+      ipcRenderer.once(responseChannel, (event, message) => {
+        const ports = (event.ports ?? []).filter((port) => port !== void 0);
+        if (ports.length === 0) {
+          console.error("[Noxus] No MessagePort received from main process.");
+          return;
+        }
+        for (const port of ports) {
+          try {
+            port.start();
+          } catch (error) {
+            console.error("[Noxus] Failed to start MessagePort.", error);
+          }
+        }
+        targetWindow.postMessage(
+          {
+            type: initMessageType,
+            senderId: message?.senderId
+          },
+          "*",
+          ports
+        );
+      });
+    }, "requestPort")
+  };
+  contextBridge.exposeInMainWorld(exposeAs, api);
+  return api;
+}
+__name(exposeNoxusBridge, "exposeNoxusBridge");
+
 // src/renderer-events.ts
 var _RendererEventRegistry = class _RendererEventRegistry {
   constructor() {
-    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+    this.listeners = /* @__PURE__ */ new Map();
   }
   /**
    *
@@ -269,11 +284,8 @@ __name(_RendererEventRegistry, "RendererEventRegistry");
 var RendererEventRegistry = _RendererEventRegistry;
 
 // src/renderer-client.ts
-var DEFAULT_INIT_EVENT = "init-port";
-var DEFAULT_BRIDGE_NAMES = [
-  "noxus",
-  "ipcRenderer"
-];
+var DEFAULT_INIT_EVENT2 = "init-port";
+var DEFAULT_BRIDGE_NAMES = ["noxus", "ipcRenderer"];
 function defaultRequestId() {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
     return crypto.randomUUID();
@@ -284,7 +296,8 @@ __name(defaultRequestId, "defaultRequestId");
 function normalizeBridgeNames(preferred) {
   const names = [];
   const add = /* @__PURE__ */ __name((name) => {
-    if (!name) return;
+    if (!name)
+      return;
     if (!names.includes(name)) {
       names.push(name);
     }
@@ -319,20 +332,10 @@ function resolveBridgeFromWindow(windowRef, preferred) {
 __name(resolveBridgeFromWindow, "resolveBridgeFromWindow");
 var _NoxRendererClient = class _NoxRendererClient {
   constructor(options = {}) {
-    __publicField(this, "events", new RendererEventRegistry());
-    __publicField(this, "pendingRequests", /* @__PURE__ */ new Map());
-    __publicField(this, "requestPort");
-    __publicField(this, "socketPort");
-    __publicField(this, "senderId");
-    __publicField(this, "bridge");
-    __publicField(this, "initMessageType");
-    __publicField(this, "windowRef");
-    __publicField(this, "generateRequestId");
-    __publicField(this, "isReady", false);
-    __publicField(this, "setupPromise");
-    __publicField(this, "setupResolve");
-    __publicField(this, "setupReject");
-    __publicField(this, "onWindowMessage", /* @__PURE__ */ __name((event) => {
+    this.events = new RendererEventRegistry();
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.isReady = false;
+    this.onWindowMessage = /* @__PURE__ */ __name((event) => {
       if (event.data?.type !== this.initMessageType) {
         return;
       }
@@ -359,14 +362,14 @@ var _NoxRendererClient = class _NoxRendererClient {
       this.isReady = true;
       this.setupResolve?.();
       this.resetSetupState(true);
-    }, "onWindowMessage"));
-    __publicField(this, "onSocketMessage", /* @__PURE__ */ __name((event) => {
+    }, "onWindowMessage");
+    this.onSocketMessage = /* @__PURE__ */ __name((event) => {
       if (this.events.tryDispatchFromMessageEvent(event)) {
         return;
       }
       console.warn("[Noxus] Received a socket message that is not a renderer event payload.", event.data);
-    }, "onSocketMessage"));
-    __publicField(this, "onRequestMessage", /* @__PURE__ */ __name((event) => {
+    }, "onSocketMessage");
+    this.onRequestMessage = /* @__PURE__ */ __name((event) => {
       if (this.events.tryDispatchFromMessageEvent(event)) {
         return;
       }
@@ -387,11 +390,11 @@ var _NoxRendererClient = class _NoxRendererClient {
         return;
       }
       pending.resolve(response.body);
-    }, "onRequestMessage"));
+    }, "onRequestMessage");
     this.windowRef = options.windowRef ?? window;
     const resolvedBridge = options.bridge ?? resolveBridgeFromWindow(this.windowRef, options.bridgeName);
     this.bridge = resolvedBridge ?? null;
-    this.initMessageType = options.initMessageType ?? DEFAULT_INIT_EVENT;
+    this.initMessageType = options.initMessageType ?? DEFAULT_INIT_EVENT2;
     this.generateRequestId = options.generateRequestId ?? defaultRequestId;
   }
   async setup() {
@@ -519,6 +522,7 @@ export {
   RendererEventRegistry,
   Request,
   createRendererEventMessage,
+  exposeNoxusBridge,
   isRendererEventMessage
 };
 /**
@@ -526,4 +530,11 @@ export {
  * @license MIT
  * @author NoxFly
  */
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ *
+ * Entry point for renderer process and preload consumers.
+ */
 //# sourceMappingURL=renderer.mjs.map

package/dist/request-BlTtiHbi.d.ts

@@ -0,0 +1,112 @@
+import { M as MaybeAsync, A as AppInjector } from './app-injector-Bz3Upc0y.js';
+
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
+/**
+ * A guard decides whether an incoming request should reach the handler.
+ * Implement this interface and pass the class to @Controller({ guards }) or @Get('path', { guards }).
+ */
+type Guard = (request: Request) => MaybeAsync<boolean>;
+
+
+/**
+ * A middleware intercepts requests before they reach guards and the handler.
+ * Implement this interface and pass the class to @Controller({ middlewares }) or per-route options.
+ */
+type Middleware = (request: Request, response: IResponse, next: NextFunction) => MaybeAsync<void>;
+type NextFunction = () => Promise<void>;
+
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
+type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
+declare function isAtomicHttpMethod(m: unknown): m is AtomicHttpMethod;
+interface IRouteOptions {
+    /**
+     * Guards specific to this route (merged with controller guards).
+     */
+    guards?: Guard[];
+    /**
+     * Middlewares specific to this route (merged with controller middlewares).
+     */
+    middlewares?: Middleware[];
+}
+interface IRouteMetadata {
+    method: HttpMethod;
+    path: string;
+    handler: string;
+    guards: Guard[];
+    middlewares: Middleware[];
+}
+declare function getRouteMetadata(target: object): IRouteMetadata[];
+declare const Get: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Post: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Put: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Patch: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Delete: (path: string, options?: IRouteOptions) => MethodDecorator;
+
+
+/**
+ * The Request class represents an HTTP request in the Noxus framework.
+ * It encapsulates the request data, including the event, ID, method, path, and body.
+ * It also provides a context for dependency injection through the AppInjector.
+ */
+declare class Request {
+    readonly event: Electron.MessageEvent;
+    readonly senderId: number;
+    readonly id: string;
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly body: any;
+    readonly context: AppInjector;
+    readonly params: Record<string, string>;
+    constructor(event: Electron.MessageEvent, senderId: number, id: string, method: HttpMethod, path: string, body: any);
+}
+/**
+ * The IRequest interface defines the structure of a request object.
+ * It includes properties for the sender ID, request ID, path, method, and an optional body.
+ * This interface is used to standardize the request data across the application.
+ */
+interface IRequest<TBody = unknown> {
+    senderId: number;
+    requestId: string;
+    path: string;
+    method: HttpMethod;
+    body?: TBody;
+}
+interface IBatchRequestItem<TBody = unknown> {
+    requestId?: string;
+    path: string;
+    method: AtomicHttpMethod;
+    body?: TBody;
+}
+interface IBatchRequestPayload {
+    requests: IBatchRequestItem[];
+}
+/**
+ * Creates a Request object from the IPC event data.
+ * This function extracts the necessary information from the IPC event and constructs a Request instance.
+ */
+interface IResponse<TBody = unknown> {
+    requestId: string;
+    status: number;
+    body?: TBody;
+    error?: string;
+    stack?: string;
+}
+interface IBatchResponsePayload {
+    responses: IResponse[];
+}
+declare const RENDERER_EVENT_TYPE = "noxus:event";
+interface IRendererEventMessage<TPayload = unknown> {
+    type: typeof RENDERER_EVENT_TYPE;
+    event: string;
+    payload?: TPayload;
+}
+declare function createRendererEventMessage<TPayload = unknown>(event: string, payload?: TPayload): IRendererEventMessage<TPayload>;
+declare function isRendererEventMessage(value: unknown): value is IRendererEventMessage;
+
+export { type AtomicHttpMethod as A, Delete as D, type Guard as G, type HttpMethod as H, type IRendererEventMessage as I, type Middleware as M, type NextFunction as N, Patch as P, RENDERER_EVENT_TYPE as R, type IResponse as a, type IRequest as b, type IBatchRequestItem as c, type IBatchResponsePayload as d, type IBatchRequestPayload as e, Request as f, createRendererEventMessage as g, Get as h, isRendererEventMessage as i, type IRouteMetadata as j, type IRouteOptions as k, Post as l, Put as m, getRouteMetadata as n, isAtomicHttpMethod as o };

package/dist/request-qJ9EiDZc.d.mts

@@ -0,0 +1,112 @@
+import { M as MaybeAsync, A as AppInjector } from './app-injector-Bz3Upc0y.mjs';
+
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
+/**
+ * A guard decides whether an incoming request should reach the handler.
+ * Implement this interface and pass the class to @Controller({ guards }) or @Get('path', { guards }).
+ */
+type Guard = (request: Request) => MaybeAsync<boolean>;
+
+
+/**
+ * A middleware intercepts requests before they reach guards and the handler.
+ * Implement this interface and pass the class to @Controller({ middlewares }) or per-route options.
+ */
+type Middleware = (request: Request, response: IResponse, next: NextFunction) => MaybeAsync<void>;
+type NextFunction = () => Promise<void>;
+
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
+type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
+declare function isAtomicHttpMethod(m: unknown): m is AtomicHttpMethod;
+interface IRouteOptions {
+    /**
+     * Guards specific to this route (merged with controller guards).
+     */
+    guards?: Guard[];
+    /**
+     * Middlewares specific to this route (merged with controller middlewares).
+     */
+    middlewares?: Middleware[];
+}
+interface IRouteMetadata {
+    method: HttpMethod;
+    path: string;
+    handler: string;
+    guards: Guard[];
+    middlewares: Middleware[];
+}
+declare function getRouteMetadata(target: object): IRouteMetadata[];
+declare const Get: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Post: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Put: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Patch: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Delete: (path: string, options?: IRouteOptions) => MethodDecorator;
+
+
+/**
+ * The Request class represents an HTTP request in the Noxus framework.
+ * It encapsulates the request data, including the event, ID, method, path, and body.
+ * It also provides a context for dependency injection through the AppInjector.
+ */
+declare class Request {
+    readonly event: Electron.MessageEvent;
+    readonly senderId: number;
+    readonly id: string;
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly body: any;
+    readonly context: AppInjector;
+    readonly params: Record<string, string>;
+    constructor(event: Electron.MessageEvent, senderId: number, id: string, method: HttpMethod, path: string, body: any);
+}
+/**
+ * The IRequest interface defines the structure of a request object.
+ * It includes properties for the sender ID, request ID, path, method, and an optional body.
+ * This interface is used to standardize the request data across the application.
+ */
+interface IRequest<TBody = unknown> {
+    senderId: number;
+    requestId: string;
+    path: string;
+    method: HttpMethod;
+    body?: TBody;
+}
+interface IBatchRequestItem<TBody = unknown> {
+    requestId?: string;
+    path: string;
+    method: AtomicHttpMethod;
+    body?: TBody;
+}
+interface IBatchRequestPayload {
+    requests: IBatchRequestItem[];
+}
+/**
+ * Creates a Request object from the IPC event data.
+ * This function extracts the necessary information from the IPC event and constructs a Request instance.
+ */
+interface IResponse<TBody = unknown> {
+    requestId: string;
+    status: number;
+    body?: TBody;
+    error?: string;
+    stack?: string;
+}
+interface IBatchResponsePayload {
+    responses: IResponse[];
+}
+declare const RENDERER_EVENT_TYPE = "noxus:event";
+interface IRendererEventMessage<TPayload = unknown> {
+    type: typeof RENDERER_EVENT_TYPE;
+    event: string;
+    payload?: TPayload;
+}
+declare function createRendererEventMessage<TPayload = unknown>(event: string, payload?: TPayload): IRendererEventMessage<TPayload>;
+declare function isRendererEventMessage(value: unknown): value is IRendererEventMessage;
+
+export { type AtomicHttpMethod as A, Delete as D, type Guard as G, type HttpMethod as H, type IRendererEventMessage as I, type Middleware as M, type NextFunction as N, Patch as P, RENDERER_EVENT_TYPE as R, type IResponse as a, type IRequest as b, type IBatchRequestItem as c, type IBatchResponsePayload as d, type IBatchRequestPayload as e, Request as f, createRendererEventMessage as g, Get as h, isRendererEventMessage as i, type IRouteMetadata as j, type IRouteOptions as k, Post as l, Put as m, getRouteMetadata as n, isAtomicHttpMethod as o };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@noxfly/noxus",
-    "version": "2.4.0",
+    "version": "3.0.0-dev.0",
     "main": "dist/main.js",
     "module": "dist/main.mjs",
     "types": "dist/main.d.ts",
@@ -45,12 +45,15 @@
         "nodejs",
         "typescript",
         "framework",
-        "web framework",
-        "electron"
+        "electron",
+        "ipc",
+        "dependency-injection",
+        "standalone",
+        "lazy-loading"
     ],
     "author": "NoxFly",
     "license": "MIT",
-    "description": "Simulate lightweight HTTP-like requests between renderer and main process in Electron applications with MessagePort, with structured and modular design.",
+    "description": "Lightweight HTTP-like IPC framework for Electron with standalone controllers, explicit DI, and lazy route loading. No reflect-metadata required.",
     "homepage": "https://github.com/NoxFly/noxus",
     "repository": {
         "type": "git",
@@ -73,8 +76,5 @@
         "tsup": "^8.5.0",
         "typescript": "^5.8.3",
         "typescript-eslint": "^8.36.0"
-    },
-    "peerDependencies": {
-        "reflect-metadata": "^0.2.2"
     }
 }