@noxfly/noxus 1.2.0 → 2.1.0

package/dist/main.mjs

@@ -315,14 +315,29 @@ function getGuardForControllerAction(controllerName, actionName) {
 __name(getGuardForControllerAction, "getGuardForControllerAction");
 var authorizations = /* @__PURE__ */ new Map();
 
+// src/decorators/injectable.metadata.ts
+var INJECTABLE_METADATA_KEY = Symbol("INJECTABLE_METADATA_KEY");
+function defineInjectableMetadata(target, lifetime) {
+  Reflect.defineMetadata(INJECTABLE_METADATA_KEY, lifetime, target);
+}
+__name(defineInjectableMetadata, "defineInjectableMetadata");
+function getInjectableMetadata(target) {
+  return Reflect.getMetadata(INJECTABLE_METADATA_KEY, target);
+}
+__name(getInjectableMetadata, "getInjectableMetadata");
+function hasInjectableMetadata(target) {
+  return Reflect.hasMetadata(INJECTABLE_METADATA_KEY, target);
+}
+__name(hasInjectableMetadata, "hasInjectableMetadata");
+
 // src/decorators/method.decorator.ts
 function createRouteDecorator(verb) {
-  return (path) => {
+  return (path2) => {
     return (target, propertyKey) => {
       const existingRoutes = Reflect.getMetadata(ROUTE_METADATA_KEY, target.constructor) || [];
       const metadata = {
         method: verb,
-        path: path.trim().replace(/^\/|\/$/g, ""),
+        path: path2.trim().replace(/^\/|\/$/g, ""),
         handler: propertyKey,
         guards: getGuardForControllerAction(target.constructor.__controllerName, propertyKey)
       };
@@ -386,6 +401,8 @@ __name(getModuleMetadata, "getModuleMetadata");
 var MODULE_METADATA_KEY = Symbol("MODULE_METADATA_KEY");
 
 // src/utils/logger.ts
+import * as fs from "fs";
+import * as path from "path";
 function getPrettyTimestamp() {
   const now = /* @__PURE__ */ new Date();
   return `${now.getDate().toString().padStart(2, "0")}/${(now.getMonth() + 1).toString().padStart(2, "0")}/${now.getFullYear()} ${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}`;
@@ -394,21 +411,41 @@ __name(getPrettyTimestamp, "getPrettyTimestamp");
 function getLogPrefix(callee, messageType, color) {
   const timestamp = getPrettyTimestamp();
   const spaces = " ".repeat(10 - messageType.length);
-  return `${color}[APP] ${process.pid} - ${Logger.colors.initial}${timestamp}${spaces}${color}${messageType.toUpperCase()}${Logger.colors.initial} ${Logger.colors.yellow}[${callee}]${Logger.colors.initial}`;
+  let colReset = Logger.colors.initial;
+  let colCallee = Logger.colors.yellow;
+  if (color === void 0) {
+    color = "";
+    colReset = "";
+    colCallee = "";
+  }
+  return `${color}[APP] ${process.pid} - ${colReset}${timestamp}${spaces}${color}${messageType.toUpperCase()}${colReset} ${colCallee}[${callee}]${colReset}`;
 }
 __name(getLogPrefix, "getLogPrefix");
-function formatObject(prefix, arg) {
+function formatObject(prefix, arg, enableColor = true) {
   const json = JSON.stringify(arg, null, 2);
-  const prefixedJson = json.split("\n").map((line, idx) => idx === 0 ? `${Logger.colors.darkGrey}${line}` : `${prefix} ${Logger.colors.grey}${line}`).join("\n") + Logger.colors.initial;
+  let colStart = "";
+  let colLine = "";
+  let colReset = "";
+  if (enableColor) {
+    colStart = Logger.colors.darkGrey;
+    colLine = Logger.colors.grey;
+    colReset = Logger.colors.initial;
+  }
+  const prefixedJson = json.split("\n").map((line, idx) => idx === 0 ? `${colStart}${line}` : `${prefix} ${colLine}${line}`).join("\n") + colReset;
   return prefixedJson;
 }
 __name(formatObject, "formatObject");
 function formattedArgs(prefix, args, color) {
+  let colReset = Logger.colors.initial;
+  if (color === void 0) {
+    color = "";
+    colReset = "";
+  }
   return args.map((arg) => {
     if (typeof arg === "string") {
-      return `${color}${arg}${Logger.colors.initial}`;
+      return `${color}${arg}${colReset}`;
     } else if (typeof arg === "object") {
-      return formatObject(prefix, arg);
+      return formatObject(prefix, arg, color === "");
     }
     return arg;
   });
@@ -421,80 +458,163 @@ function getCallee() {
 }
 __name(getCallee, "getCallee");
 function canLog(level) {
-  return logLevelRank[level] >= logLevelRank[logLevel];
+  return logLevels.has(level);
 }
 __name(canLog, "canLog");
-var logLevel = "debug";
-var logLevelRank = {
-  debug: 0,
-  comment: 1,
-  log: 2,
-  info: 3,
-  warn: 4,
-  error: 5
-};
+function processLogQueue(filepath) {
+  const state = fileStates.get(filepath);
+  if (!state || state.isWriting || state.queue.length === 0) {
+    return;
+  }
+  state.isWriting = true;
+  const messagesToWrite = state.queue.join("\n") + "\n";
+  state.queue = [];
+  const dir = path.dirname(filepath);
+  fs.mkdir(dir, {
+    recursive: true
+  }, (err) => {
+    if (err) {
+      console.error(`[Logger] Failed to create directory ${dir}`, err);
+      state.isWriting = false;
+      return;
+    }
+    fs.appendFile(filepath, messagesToWrite, {
+      encoding: "utf-8"
+    }, (err2) => {
+      state.isWriting = false;
+      if (err2) {
+        console.error(`[Logger] Failed to write log to ${filepath}`, err2);
+      }
+      if (state.queue.length > 0) {
+        processLogQueue(filepath);
+      }
+    });
+  });
+}
+__name(processLogQueue, "processLogQueue");
+function enqueue(filepath, message) {
+  if (!fileStates.has(filepath)) {
+    fileStates.set(filepath, {
+      queue: [],
+      isWriting: false
+    });
+  }
+  const state = fileStates.get(filepath);
+  state.queue.push(message);
+  processLogQueue(filepath);
+}
+__name(enqueue, "enqueue");
+function output(level, args) {
+  if (!canLog(level)) {
+    return;
+  }
+  const callee = getCallee();
+  {
+    const prefix = getLogPrefix(callee, level, logLevelColors[level]);
+    const data = formattedArgs(prefix, args, logLevelColors[level]);
+    logLevelChannel[level](prefix, ...data);
+  }
+  {
+    const prefix = getLogPrefix(callee, level);
+    const data = formattedArgs(prefix, args);
+    const filepath = fileSettings.get(level)?.filepath;
+    if (filepath) {
+      const message = prefix + " " + data.join(" ");
+      enqueue(filepath, message);
+    }
+  }
+}
+__name(output, "output");
 (function(Logger2) {
   function setLogLevel(level) {
-    logLevel = level;
+    logLevels.clear();
+    if (Array.isArray(level)) {
+      for (const lvl of level) {
+        logLevels.add(lvl);
+      }
+    } else {
+      const targetRank = logLevelRank[level];
+      for (const [lvl, rank] of Object.entries(logLevelRank)) {
+        if (rank >= targetRank) {
+          logLevels.add(lvl);
+        }
+      }
+    }
   }
   __name(setLogLevel, "setLogLevel");
   Logger2.setLogLevel = setLogLevel;
   function log(...args) {
-    if (!canLog("log")) return;
-    const callee = getCallee();
-    const prefix = getLogPrefix(callee, "log", Logger2.colors.green);
-    console.log(prefix, ...formattedArgs(prefix, args, Logger2.colors.green));
+    output("log", args);
   }
   __name(log, "log");
   Logger2.log = log;
   function info(...args) {
-    if (!canLog("info")) return;
-    const callee = getCallee();
-    const prefix = getLogPrefix(callee, "info", Logger2.colors.blue);
-    console.info(prefix, ...formattedArgs(prefix, args, Logger2.colors.blue));
+    output("info", args);
   }
   __name(info, "info");
   Logger2.info = info;
   function warn(...args) {
-    if (!canLog("warn")) return;
-    const callee = getCallee();
-    const prefix = getLogPrefix(callee, "warn", Logger2.colors.brown);
-    console.warn(prefix, ...formattedArgs(prefix, args, Logger2.colors.brown));
+    output("warn", args);
   }
   __name(warn, "warn");
   Logger2.warn = warn;
   function error(...args) {
-    if (!canLog("error")) return;
-    const callee = getCallee();
-    const prefix = getLogPrefix(callee, "error", Logger2.colors.red);
-    console.error(prefix, ...formattedArgs(prefix, args, Logger2.colors.red));
+    output("error", args);
   }
   __name(error, "error");
   Logger2.error = error;
   function errorStack(...args) {
-    if (!canLog("error")) return;
-    const callee = getCallee();
-    const prefix = getLogPrefix(callee, "error", Logger2.colors.grey);
-    console.error(prefix, ...formattedArgs(prefix, args, Logger2.colors.grey));
+    output("error", args);
   }
   __name(errorStack, "errorStack");
   Logger2.errorStack = errorStack;
   function debug(...args) {
-    if (!canLog("debug")) return;
-    const callee = getCallee();
-    const prefix = getLogPrefix(callee, "debug", Logger2.colors.purple);
-    console.debug(prefix, ...formattedArgs(prefix, args, Logger2.colors.purple));
+    output("debug", args);
   }
   __name(debug, "debug");
   Logger2.debug = debug;
   function comment(...args) {
-    if (!canLog("comment")) return;
-    const callee = getCallee();
-    const prefix = getLogPrefix(callee, "comment", Logger2.colors.grey);
-    console.debug(prefix, ...formattedArgs(prefix, args, Logger2.colors.grey));
+    output("comment", args);
   }
   __name(comment, "comment");
   Logger2.comment = comment;
+  function critical(...args) {
+    output("critical", args);
+  }
+  __name(critical, "critical");
+  Logger2.critical = critical;
+  function enableFileLogging(filepath, levels = [
+    "debug",
+    "comment",
+    "log",
+    "info",
+    "warn",
+    "error",
+    "critical"
+  ]) {
+    for (const level of levels) {
+      fileSettings.set(level, {
+        filepath
+      });
+    }
+  }
+  __name(enableFileLogging, "enableFileLogging");
+  Logger2.enableFileLogging = enableFileLogging;
+  function disableFileLogging(levels = [
+    "debug",
+    "comment",
+    "log",
+    "info",
+    "warn",
+    "error",
+    "critical"
+  ]) {
+    for (const level of levels) {
+      fileSettings.delete(level);
+    }
+  }
+  __name(disableFileLogging, "disableFileLogging");
+  Logger2.disableFileLogging = disableFileLogging;
   Logger2.colors = {
     black: "\x1B[0;30m",
     grey: "\x1B[0;37m",
@@ -514,6 +634,37 @@ var logLevelRank = {
     initial: "\x1B[0m"
   };
 })(Logger || (Logger = {}));
+var fileSettings = /* @__PURE__ */ new Map();
+var fileStates = /* @__PURE__ */ new Map();
+var logLevels = /* @__PURE__ */ new Set();
+var logLevelRank = {
+  debug: 0,
+  comment: 1,
+  log: 2,
+  info: 3,
+  warn: 4,
+  error: 5,
+  critical: 6
+};
+var logLevelColors = {
+  debug: Logger.colors.purple,
+  comment: Logger.colors.grey,
+  log: Logger.colors.green,
+  info: Logger.colors.blue,
+  warn: Logger.colors.brown,
+  error: Logger.colors.red,
+  critical: Logger.colors.lightRed
+};
+var logLevelChannel = {
+  debug: console.debug,
+  comment: console.debug,
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error,
+  critical: console.error
+};
+Logger.setLogLevel("debug");
 var Logger;
 
 // src/DI/injector-explorer.ts
@@ -562,22 +713,17 @@ function Injectable(lifetime = "scope") {
     if (typeof target !== "function" || !target.prototype) {
       throw new Error(`@Injectable can only be used on classes, not on ${typeof target}`);
     }
-    Reflect.defineMetadata(INJECTABLE_METADATA_KEY, lifetime, target);
+    defineInjectableMetadata(target, lifetime);
     InjectorExplorer.register(target, lifetime);
   };
 }
 __name(Injectable, "Injectable");
-function getInjectableMetadata(target) {
-  return Reflect.getMetadata(INJECTABLE_METADATA_KEY, target);
-}
-__name(getInjectableMetadata, "getInjectableMetadata");
-var INJECTABLE_METADATA_KEY = Symbol("INJECTABLE_METADATA_KEY");
 
 // src/decorators/controller.decorator.ts
-function Controller(path) {
+function Controller(path2) {
   return (target) => {
     const data = {
-      path,
+      path: path2,
       guards: getGuardForController(target.name)
     };
     Reflect.defineMetadata(CONTROLLER_METADATA_KEY, data, target);
@@ -625,8 +771,9 @@ var middlewares = /* @__PURE__ */ new Map();
 // src/request.ts
 import "reflect-metadata";
 var _Request = class _Request {
-  constructor(event, id, method, path, body) {
+  constructor(event, senderId, id, method, path2, body) {
     __publicField(this, "event");
+    __publicField(this, "senderId");
     __publicField(this, "id");
     __publicField(this, "method");
     __publicField(this, "path");
@@ -634,11 +781,12 @@ var _Request = class _Request {
     __publicField(this, "context", RootInjector.createScope());
     __publicField(this, "params", {});
     this.event = event;
+    this.senderId = senderId;
     this.id = id;
     this.method = method;
-    this.path = path;
+    this.path = path2;
     this.body = body;
-    this.path = path.replace(/^\/|\/$/g, "");
+    this.path = path2.replace(/^\/|\/$/g, "");
   }
 };
 __name(_Request, "Request");
@@ -720,8 +868,8 @@ var _RadixTree = class _RadixTree {
    * @param path - The path to insert into the tree.
    * @param value - The value to associate with the path.
    */
-  insert(path, value) {
-    const segments = this.normalize(path);
+  insert(path2, value) {
+    const segments = this.normalize(path2);
     this.insertRecursive(this.root, segments, value);
   }
   /**
@@ -750,8 +898,8 @@ var _RadixTree = class _RadixTree {
    * @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(path) {
-    const segments = this.normalize(path);
+  search(path2) {
+    const segments = this.normalize(path2);
     return this.searchRecursive(this.root, segments, {});
   }
   /**
@@ -807,8 +955,8 @@ var _RadixTree = class _RadixTree {
    * @param path - The path to normalize.
    * @returns An array of normalized path segments.
    */
-  normalize(path) {
-    const segments = path.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+  normalize(path2) {
+    const segments = path2.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
     return [
       "",
       ...segments
@@ -918,6 +1066,7 @@ var _Router = class _Router {
       status: 200,
       body: null
     };
+    let isCritical = false;
     try {
       const routeDef = this.findRoute(request);
       await this.resolveController(request, response, routeDef);
@@ -931,10 +1080,12 @@ var _Router = class _Router {
         response.error = error.message;
         response.stack = error.stack;
       } else if (error instanceof Error) {
+        isCritical = true;
         response.status = 500;
         response.error = error.message || "Internal Server Error";
         response.stack = error.stack || "No stack trace available";
       } else {
+        isCritical = true;
         response.status = 500;
         response.error = "Unknown error occurred";
         response.stack = "No stack trace available";
@@ -942,11 +1093,23 @@ var _Router = class _Router {
     } finally {
       const t1 = performance.now();
       const message = `< ${response.status} ${request.method} /${request.path} ${Logger.colors.yellow}${Math.round(t1 - t0)}ms${Logger.colors.initial}`;
-      if (response.status < 400) Logger.log(message);
-      else if (response.status < 500) Logger.warn(message);
-      else Logger.error(message);
+      if (response.status < 400) {
+        Logger.log(message);
+      } else if (response.status < 500) {
+        Logger.warn(message);
+      } else {
+        if (isCritical) {
+          Logger.critical(message);
+        } else {
+          Logger.error(message);
+        }
+      }
       if (response.error !== void 0) {
-        Logger.error(response.error);
+        if (isCritical) {
+          Logger.critical(response.error);
+        } else {
+          Logger.error(response.error);
+        }
         if (response.stack !== void 0) {
           Logger.errorStack(response.stack);
         }
@@ -964,12 +1127,13 @@ var _Router = class _Router {
         responses: []
       }
     };
+    let isCritical = false;
     try {
       const payload = this.normalizeBatchPayload(request.body);
       const batchResponses = [];
       for (const [index, item] of payload.requests.entries()) {
         const subRequestId = item.requestId ?? `${request.id}:${index}`;
-        const atomicRequest = new Request(request.event, subRequestId, item.method, item.path, item.body);
+        const atomicRequest = new Request(request.event, request.senderId, subRequestId, item.method, item.path, item.body);
         batchResponses.push(await this.handleAtomic(atomicRequest));
       }
       response.body.responses = batchResponses;
@@ -980,10 +1144,12 @@ var _Router = class _Router {
         response.error = error.message;
         response.stack = error.stack;
       } else if (error instanceof Error) {
+        isCritical = true;
         response.status = 500;
         response.error = error.message || "Internal Server Error";
         response.stack = error.stack || "No stack trace available";
       } else {
+        isCritical = true;
         response.status = 500;
         response.error = "Unknown error occurred";
         response.stack = "No stack trace available";
@@ -991,11 +1157,23 @@ var _Router = class _Router {
     } finally {
       const t1 = performance.now();
       const message = `< ${response.status} ${request.method} /${request.path} ${Logger.colors.yellow}${Math.round(t1 - t0)}ms${Logger.colors.initial}`;
-      if (response.status < 400) Logger.log(message);
-      else if (response.status < 500) Logger.warn(message);
-      else Logger.error(message);
+      if (response.status < 400) {
+        Logger.log(message);
+      } else if (response.status < 500) {
+        Logger.warn(message);
+      } else {
+        if (isCritical) {
+          Logger.critical(message);
+        } else {
+          Logger.error(message);
+        }
+      }
       if (response.error !== void 0) {
-        Logger.error(response.error);
+        if (isCritical) {
+          Logger.critical(response.error);
+        } else {
+          Logger.error(response.error);
+        }
         if (response.stack !== void 0) {
           Logger.errorStack(response.stack);
         }
@@ -1021,11 +1199,11 @@ var _Router = class _Router {
     if (entry === null || typeof entry !== "object") {
       throw new BadRequestException(`Batch request at index ${index} must be an object.`);
     }
-    const { requestId, path, method, body } = entry;
+    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 path !== "string" || path.length === 0) {
+    if (typeof path2 !== "string" || path2.length === 0) {
       throw new BadRequestException(`Batch request at index ${index} must define a non-empty path.`);
     }
     if (typeof method !== "string") {
@@ -1037,7 +1215,7 @@ var _Router = class _Router {
     }
     return {
       requestId,
-      path,
+      path: path2,
       method: normalizedMethod,
       body
     };
@@ -1189,20 +1367,23 @@ function _ts_decorate2(decorators, target, key, desc) {
 __name(_ts_decorate2, "_ts_decorate");
 var _NoxSocket = class _NoxSocket {
   constructor() {
-    __publicField(this, "messagePorts", /* @__PURE__ */ new Map());
+    __publicField(this, "channels", /* @__PURE__ */ new Map());
   }
-  register(senderId, channel) {
-    this.messagePorts.set(senderId, channel);
+  register(senderId, requestChannel, socketChannel) {
+    this.channels.set(senderId, {
+      request: requestChannel,
+      socket: socketChannel
+    });
   }
   get(senderId) {
-    return this.messagePorts.get(senderId);
+    return this.channels.get(senderId);
   }
   unregister(senderId) {
-    this.messagePorts.delete(senderId);
+    this.channels.delete(senderId);
   }
   getSenderIds() {
     return [
-      ...this.messagePorts.keys()
+      ...this.channels.keys()
     ];
   }
   emit(eventName, payload, targetSenderIds) {
@@ -1213,13 +1394,13 @@ var _NoxSocket = class _NoxSocket {
     const recipients = targetSenderIds ?? this.getSenderIds();
     let delivered = 0;
     for (const senderId of recipients) {
-      const channel = this.messagePorts.get(senderId);
+      const channel = this.channels.get(senderId);
       if (!channel) {
         Logger.warn(`No message channel found for sender ID: ${senderId} while emitting "${normalizedEvent}".`);
         continue;
       }
       try {
-        channel.port1.postMessage(createRendererEventMessage(normalizedEvent, payload));
+        channel.socket.port1.postMessage(createRendererEventMessage(normalizedEvent, payload));
         delivered++;
       } catch (error) {
         Logger.error(`[Noxus] Failed to emit "${normalizedEvent}" to sender ${senderId}.`, error);
@@ -1256,17 +1437,20 @@ var _NoxApp = class _NoxApp {
     __publicField(this, "router");
     __publicField(this, "socket");
     __publicField(this, "app");
+    /**
+     *
+     */
     __publicField(this, "onRendererMessage", /* @__PURE__ */ __name(async (event) => {
-      const { senderId, requestId, path, method, body } = event.data;
-      const channel = this.socket.get(senderId);
-      if (!channel) {
+      const { senderId, requestId, path: path2, method, body } = 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, requestId, method, path, body);
+        const request = new Request(event, senderId, requestId, method, path2, body);
         const response = await this.router.handle(request);
-        channel.port1.postMessage(response);
+        channels.request.port1.postMessage(response);
       } catch (err) {
         const response = {
           requestId,
@@ -1274,7 +1458,7 @@ var _NoxApp = class _NoxApp {
           body: null,
           error: err.message || "Internal Server Error"
         };
-        channel.port1.postMessage(response);
+        channels.request.port1.postMessage(response);
       }
     }, "onRendererMessage"));
     this.router = router;
@@ -1303,14 +1487,17 @@ var _NoxApp = class _NoxApp {
     if (this.socket.get(senderId)) {
       this.shutdownChannel(senderId);
     }
-    const channel = new MessageChannelMain();
-    channel.port1.on("message", this.onRendererMessage);
-    channel.port1.start();
-    this.socket.register(senderId, channel);
+    const requestChannel = new MessageChannelMain();
+    const socketChannel = new MessageChannelMain();
+    requestChannel.port1.on("message", this.onRendererMessage);
+    requestChannel.port1.start();
+    socketChannel.port1.start();
+    this.socket.register(senderId, requestChannel, socketChannel);
     event.sender.postMessage("port", {
       senderId
     }, [
-      channel.port2
+      requestChannel.port2,
+      socketChannel.port2
     ]);
   }
   /**
@@ -1329,14 +1516,16 @@ var _NoxApp = class _NoxApp {
    * @param remove - Whether to remove the channel from the messagePorts map.
    */
   shutdownChannel(channelSenderId) {
-    const channel = this.socket.get(channelSenderId);
-    if (!channel) {
+    const channels = this.socket.get(channelSenderId);
+    if (!channels) {
       Logger.warn(`No message channel found for sender ID: ${channelSenderId}`);
       return;
     }
-    channel.port1.off("message", this.onRendererMessage);
-    channel.port1.close();
-    channel.port2.close();
+    channels.request.port1.off("message", this.onRendererMessage);
+    channels.request.port1.close();
+    channels.request.port2.close();
+    channels.socket.port1.close();
+    channels.socket.port2.close();
     this.socket.unregister(channelSenderId);
   }
   /**
@@ -1407,6 +1596,42 @@ async function bootstrapApplication(rootModule) {
 }
 __name(bootstrapApplication, "bootstrapApplication");
 
+// 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() {
@@ -1486,6 +1711,252 @@ var _RendererEventRegistry = class _RendererEventRegistry {
 };
 __name(_RendererEventRegistry, "RendererEventRegistry");
 var RendererEventRegistry = _RendererEventRegistry;
+
+// src/renderer-client.ts
+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();
+  }
+  return `${Date.now().toString(16)}-${Math.floor(Math.random() * 1e8).toString(16)}`;
+}
+__name(defaultRequestId, "defaultRequestId");
+function normalizeBridgeNames(preferred) {
+  const names = [];
+  const add = /* @__PURE__ */ __name((name) => {
+    if (!name) return;
+    if (!names.includes(name)) {
+      names.push(name);
+    }
+  }, "add");
+  if (Array.isArray(preferred)) {
+    for (const name of preferred) {
+      add(name);
+    }
+  } else {
+    add(preferred);
+  }
+  for (const fallback of DEFAULT_BRIDGE_NAMES) {
+    add(fallback);
+  }
+  return names;
+}
+__name(normalizeBridgeNames, "normalizeBridgeNames");
+function resolveBridgeFromWindow(windowRef, preferred) {
+  const names = normalizeBridgeNames(preferred);
+  const globalRef = windowRef;
+  if (!globalRef) {
+    return null;
+  }
+  for (const name of names) {
+    const candidate = globalRef[name];
+    if (candidate && typeof candidate.requestPort === "function") {
+      return candidate;
+    }
+  }
+  return null;
+}
+__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) => {
+      if (event.data?.type !== this.initMessageType) {
+        return;
+      }
+      if (!Array.isArray(event.ports) || event.ports.length < 2) {
+        const error = new Error("[Noxus] Renderer expected two MessagePorts (request + socket).");
+        console.error(error);
+        this.setupReject?.(error);
+        this.resetSetupState();
+        return;
+      }
+      this.windowRef.removeEventListener("message", this.onWindowMessage);
+      this.requestPort = event.ports[0];
+      this.socketPort = event.ports[1];
+      this.senderId = event.data.senderId;
+      if (this.requestPort === void 0 || this.socketPort === void 0) {
+        const error = new Error("[Noxus] Renderer failed to receive valid MessagePorts.");
+        console.error(error);
+        this.setupReject?.(error);
+        this.resetSetupState();
+        return;
+      }
+      this.attachRequestPort(this.requestPort);
+      this.attachSocketPort(this.socketPort);
+      this.isReady = true;
+      this.setupResolve?.();
+      this.resetSetupState(true);
+    }, "onWindowMessage"));
+    __publicField(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) => {
+      if (this.events.tryDispatchFromMessageEvent(event)) {
+        return;
+      }
+      const response = event.data;
+      if (!response || typeof response.requestId !== "string") {
+        console.error("[Noxus] Renderer received an invalid response payload.", response);
+        return;
+      }
+      const pending = this.pendingRequests.get(response.requestId);
+      if (!pending) {
+        console.error(`[Noxus] No pending handler found for request ${response.requestId}.`);
+        return;
+      }
+      this.pendingRequests.delete(response.requestId);
+      this.onRequestCompleted(pending, response);
+      if (response.status >= 400) {
+        pending.reject(response);
+        return;
+      }
+      pending.resolve(response.body);
+    }, "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_EVENT2;
+    this.generateRequestId = options.generateRequestId ?? defaultRequestId;
+  }
+  async setup() {
+    if (this.isReady) {
+      return Promise.resolve();
+    }
+    if (this.setupPromise) {
+      return this.setupPromise;
+    }
+    if (!this.bridge || typeof this.bridge.requestPort !== "function") {
+      throw new Error("[Noxus] Renderer bridge is missing requestPort().");
+    }
+    this.setupPromise = new Promise((resolve, reject) => {
+      this.setupResolve = resolve;
+      this.setupReject = reject;
+    });
+    this.windowRef.addEventListener("message", this.onWindowMessage);
+    this.bridge.requestPort();
+    return this.setupPromise;
+  }
+  dispose() {
+    this.windowRef.removeEventListener("message", this.onWindowMessage);
+    this.requestPort?.close();
+    this.socketPort?.close();
+    this.requestPort = void 0;
+    this.socketPort = void 0;
+    this.senderId = void 0;
+    this.isReady = false;
+    this.pendingRequests.clear();
+  }
+  async request(request) {
+    const senderId = this.senderId;
+    const requestId = this.generateRequestId();
+    if (senderId === void 0) {
+      return Promise.reject(this.createErrorResponse(requestId, "MessagePort is not available"));
+    }
+    const readinessError = this.validateReady(requestId);
+    if (readinessError) {
+      return Promise.reject(readinessError);
+    }
+    const message = {
+      requestId,
+      senderId,
+      ...request
+    };
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject: /* @__PURE__ */ __name((response) => reject(response), "reject"),
+        request: message,
+        submittedAt: Date.now()
+      };
+      this.pendingRequests.set(message.requestId, pending);
+      this.requestPort.postMessage(message);
+    });
+  }
+  async batch(requests) {
+    return this.request({
+      method: "BATCH",
+      path: "",
+      body: {
+        requests
+      }
+    });
+  }
+  getSenderId() {
+    return this.senderId;
+  }
+  onRequestCompleted(pending, response) {
+    if (typeof console.groupCollapsed === "function") {
+      console.groupCollapsed(`${response.status} ${pending.request.method} /${pending.request.path}`);
+    }
+    if (response.error) {
+      console.error("error message:", response.error);
+    }
+    if (response.body !== void 0) {
+      console.info("response:", response.body);
+    }
+    console.info("request:", pending.request);
+    console.info(`Request duration: ${Date.now() - pending.submittedAt} ms`);
+    if (typeof console.groupCollapsed === "function") {
+      console.groupEnd();
+    }
+  }
+  attachRequestPort(port) {
+    port.onmessage = this.onRequestMessage;
+    port.start();
+  }
+  attachSocketPort(port) {
+    port.onmessage = this.onSocketMessage;
+    port.start();
+  }
+  validateReady(requestId) {
+    if (!this.isElectronEnvironment()) {
+      return this.createErrorResponse(requestId, "Not running in Electron environment");
+    }
+    if (!this.requestPort) {
+      return this.createErrorResponse(requestId, "MessagePort is not available");
+    }
+    return void 0;
+  }
+  createErrorResponse(requestId, message) {
+    return {
+      status: 500,
+      requestId,
+      error: message
+    };
+  }
+  resetSetupState(success = false) {
+    if (!success) {
+      this.setupPromise = void 0;
+    }
+    this.setupResolve = void 0;
+    this.setupReject = void 0;
+  }
+  isElectronEnvironment() {
+    return typeof window !== "undefined" && /Electron/.test(window.navigator.userAgent);
+  }
+};
+__name(_NoxRendererClient, "NoxRendererClient");
+var NoxRendererClient = _NoxRendererClient;
 export {
   AppInjector,
   Authorize,
@@ -1515,6 +1986,7 @@ export {
   NotFoundException,
   NotImplementedException,
   NoxApp,
+  NoxRendererClient,
   NoxSocket,
   Patch,
   PaymentRequiredException,
@@ -1536,6 +2008,7 @@ export {
   VariantAlsoNegotiatesException,
   bootstrapApplication,
   createRendererEventMessage,
+  exposeNoxusBridge,
   getControllerMetadata,
   getGuardForController,
   getGuardForControllerAction,
@@ -1544,6 +2017,7 @@ export {
   getMiddlewaresForControllerAction,
   getModuleMetadata,
   getRouteMetadata,
+  hasInjectableMetadata,
   inject,
   isRendererEventMessage
 };