@noxfly/noxus 1.2.0 → 2.0.0

package/.github/copilot-instructions.md

@@ -0,0 +1,32 @@
+# Copilot Instructions
+## Core Architecture
+- bootstrapApplication in [src/bootstrap.ts](src/bootstrap.ts) waits for Electron app readiness, resolves NoxApp via DI, and returns a configured instance.
+- [src/app.ts](src/app.ts) wires ipcMain events, spawns paired request/socket MessageChannels per renderer, and delegates handling to Router and NoxSocket.
+- Package exports are split between renderer and main targets in [package.json](package.json); import Electron main APIs from @noxfly/noxus/main and renderer helpers from @noxfly/noxus or @noxfly/noxus/renderer.
+- Dependency injection centers on RootInjector in [src/DI/app-injector.ts](src/DI/app-injector.ts); @Injectable triggers auto-registration through [src/DI/injector-explorer.ts](src/DI/injector-explorer.ts) and supports singleton, scope, and transient lifetimes.
+- Modules decorated via [src/decorators/module.decorator.ts](src/decorators/module.decorator.ts) compose providers, controllers, and nested modules; bootstrapApplication rejects roots lacking Module metadata.
+## Request Lifecycle
+- Request objects from [src/request.ts](src/request.ts) wrap Electron MessageEvents and spawn per-request DI scopes on Request.context.
+- Router in [src/router.ts](src/router.ts) indexes routes in a radix tree, merges controller-level and method-level decorators, and enforces root middlewares, route middlewares, then guards before invoking controller actions.
+- ResponseException subclasses in [src/exceptions.ts](src/exceptions.ts) propagate status codes; throwing one short-circuits the pipeline so Router returns a structured error payload.
+- Batch requests use HTTP method BATCH and normalization logic in Router.handleBatch; payloads must satisfy IBatchRequestPayload to fan out atomic subrequests.
+## Communication Channels
+- ipcMain listens for gimme-my-port and posts two transferable ports back to the renderer: index 0 carries request/response traffic, index 1 is reserved for socket-style push messages.
+- NoxSocket in [src/socket.ts](src/socket.ts) maps sender IDs to {request, socket} channels and emits renderer events exclusively through channels.socket.port1.
+- Renderer helpers in [src/renderer-events.ts](src/renderer-events.ts) expose RendererEventRegistry.tryDispatchFromMessageEvent to route push events; the preload script must start both ports and hand the second to this registry.
+- Renderer-facing bootstrap lives in [src/renderer-client.ts](src/renderer-client.ts); NoxRendererClient requests ports, wires request/socket handlers, tracks pending promises, and surfaces RendererEventRegistry for push consumption.
+- Preload scripts should call exposeNoxusBridge from [src/preload-bridge.ts](src/preload-bridge.ts) to publish window.noxus.requestPort; the helper sends 'gimme-my-port' and forwards both transferable ports with the configured init message.
+- When adjusting preload or renderer glue, ensure window.postMessage('init-port', ...) forwards both ports so the socket channel stays alive alongside the request channel.
+## Decorator Conventions
+- Controller paths omit leading/trailing slashes; method decorators (Get, Post, etc.) auto-trim segments via [src/decorators/method.decorator.ts](src/decorators/method.decorator.ts).
+- Guards registered through Authorize in [src/decorators/guards.decorator.ts](src/decorators/guards.decorator.ts) aggregate at controller and action scope; they must resolve truthy or Router throws UnauthorizedException.
+- Injectable lifetimes default to scope; use singleton for app-wide utilities (window managers, sockets) and transient for short-lived resources.
+## Logging and Utilities
+- Logger in [src/utils/logger.ts](src/utils/logger.ts) standardizes color-coded log, warn, error, and comment output; use it when extending framework behavior.
+- Path resolution relies on RadixTree from [src/utils/radix-tree.ts](src/utils/radix-tree.ts); normalize controller and route paths to avoid duplicate slashes.
+- Request.params are filled by Router.extractParams; controllers read route params directly from Request without decorator helpers yet.
+## Build and Tooling
+- Run npm run build to invoke tsup with dual ESM/CJS outputs configured in [tsup.config.ts](tsup.config.ts); the postbuild script at [scripts/postbuild.js](scripts/postbuild.js) deduplicates license banners.
+- Node 20 or newer is required; reflect-metadata is a peer dependency so host apps must install and import it before using decorators.
+- Source uses baseUrl ./ with tsc-alias, so prefer absolute imports like src/module/file when editing framework code to match existing style.
+- Dist artifacts live under dist/ and are published outputs; regenerate them via the build script rather than editing directly.

package/README.md

@@ -34,20 +34,12 @@ Noxus fills that gap.
 
 ## Installation
 
-Install the package in your main process application :
+Install the package in your main process application, and in your renderer as well :
 
 ```sh
 npm i @noxfly/noxus
 ```
 
-If you have a separated renderer from the main process, you'd like to install the package as well to get typed requests/responses models, for development purposes :
-
-```sh
-npm i -D @noxfly/noxus
-```
-
-Because you only need types during development, using the `-D` argument will make this package a `devDependency`, thus won't be present on your build.
-
 > ⚠️ The default entry (`@noxfly/noxus`) only exposes renderer-friendly helpers and types. Import Electron main-process APIs from `@noxfly/noxus/main`.
 
 ## Basic use
@@ -202,145 +194,62 @@ We need some configuration on the preload so the main process can give the rende
 ```ts
 // main/preload.ts
 
-import { contextBridge, ipcRenderer } from 'electron/renderer';
-
-// .invoke -> front sends to back
-// .on -> back sends to front
-
-type fn = (...args: any[]) => void;
+import { exposeNoxusBridge } from '@noxfly/noxus';
 
-contextBridge.exposeInMainWorld('ipcRenderer', {
-    requestPort: () => ipcRenderer.send('gimme-my-port'),
-    
-    hereIsMyPort: () => ipcRenderer.once('port', (e, message) => {
-        e.ports[0]?.start();
-        window.postMessage({ type: 'init-port', senderId: message.senderId }, '*', [e.ports[0]!]);
-    }),
-});
+exposeNoxusBridge();
 ```
 
-> ⚠️ As the Electron documentation warns well, you should NEVER expose the whole ipcRenderer to the renderer. Expose only restricted API that your renderer could use.
+The helper uses `ipcRenderer.send('gimme-my-port')`, waits for the `'port'` response, starts both transferred `MessagePort`s, and forwards them to the renderer with `window.postMessage({ type: 'init-port', ... }, '*', [requestPort, socketPort])`. If you need to customise any channel names or the exposed property, pass `exposeNoxusBridge({ exposeAs: 'customNoxus', requestChannel: 'my-port', responseChannel: 'my-port-ready', initMessageType: 'custom-init' })`.
 
-We need to use `window.postMessage()` and not a custom callback function, otherwise the port would have been structuredCloned and would only arrive to the renderer with the `onmessage` function, and nothing else (a bit frustrating to not request, isn't it).
+> ⚠️ As the Electron documentation warns, never expose the full `ipcRenderer` object. The helper only reveals a minimal `{ requestPort }` surface under `window.noxus` by default.
 
 
 ### Setup Renderer
 
-I am personnally using Angular as renderer, so there might be some changes if you use another framework or vanilla js, but it is only about typescript's configuration and types.
-
-Maybe this should become a class directly available from @noxfly/noxus;
+Noxus ships with a `NoxRendererClient` helper that performs the renderer bootstrap: it asks the preload bridge for a port, expects two transferable `MessagePort`s (index `0` for request/response and index `1` for socket pushes), wires both, and exposes a promise-based `request`/`batch` API plus the `RendererEventRegistry` instance.
 
-```ts
-// renderer/anyFileAtStartup.ts
+By default it calls `window.noxus.requestPort()`—the value registered by `exposeNoxusBridge()`—but you can pass a custom bridge through the constructor options if needed.
 
-import { IRequest, IResponse } from '@noxfly/noxus';
+Call `await client.setup()` early in your renderer startup (for example inside the first Angular service that needs IPC). Once the promise resolves, `client.request(...)` automatically includes the negotiated `senderId`, and socket events are routed through `client.events`.
 
-interface PendingRequestHandlers<T> {
-    resolve: (value: IResponse<T>) => void;
-    reject: (reason?: IResponse<T>) => void;
-    request: IRequest;
-}
-
-// might be a singleton service
-class ElectronService {
-    private readonly bridge: any;
-    private readonly ipcRenderer: any; // if you know how to get a type, tell me
-
-    private port: MessagePort | undefined;
-    private senderId: number | undefined;
-    private readonly pendingRequests = new Map<string, PendingRequestsHandlers<any>>();
-
-    constructor() {
-        this.bridge = window as any;
-        this.ipcRenderer = this.bridge.ipcRenderer;
-
-        // when receiving the port given by the main renderer -> preload -> renderer
-        window.addEventListener('message', (event: MessageEvent) => {
-            if(event.data?.type === 'init-port' && event.ports.length > 0) {
-                this.port = event.ports[0]!;
-                this.senderId = event.data.senderId;
-                this.port.onmessage = onResponse;
-            }
-        });
-
-        ipcRenderer.requestPort();
+```ts
+// renderer/services/noxus.service.ts
+
+import { Injectable } from '@angular/core';
+import { from, Observable } from 'rxjs';
+import {
+    IBatchRequestItem,
+    IBatchResponsePayload,
+    IRequest,
+    NoxRendererClient,
+} from '@noxfly/noxus';
+
+@Injectable({ providedIn: 'root' })
+export class NoxusService extends NoxRendererClient {
+    public async init(): Promise<void> {
+        await this.setup();
     }
 
-    /**
-     * Resolve the signal-based response
-     */
-    private onResponse(event: MessageEvent): void {
-        const response: IResponse<unknown> = event.data;
-
-        if(!response || !response.requestId) {
-            console.error('Received invalid response:', response);
-            return;
-        }
-
-        const pending = this.pendingRequests.get(response.requestId);
-        
-        if(!pending) {
-            console.error(`No handler found for request ID: ${response.requestId}`);
-            return;
-        }
-        
-        this.pendingRequests.delete(response.requestId);
-
-        let fn: (response: IResponse<unknown>) => void = pending.resolve;
-
-        console.groupCollapsed(`${response.status} ${pending.request.method} /${pending.request.path}`);
-        
-        if(response.error) {
-            console.error('error message:', response.error);
-            fn = pending.reject;
-        }
-        
-        console.info('response:', response.body);
-        console.info('request:', pending.request);
-
-        console.groupEnd();
-
-        fn(response);
+    public request$<T, U = unknown>(request: Omit<IRequest<U>, 'requestId' | 'senderId'>): Observable<T> {
+        return from(this.request<T, U>(request));
     }
 
-    /**
-     * Initiate a request to the main process
-     */
-    public request<T>(request: Omit<IRequest, 'requestId' | 'senderId'>): Promise<T> {
-        return new Promise<T>((resolve, reject) => {
-            if(!this.port || !this.senderId) {
-                return reject(new Error("MessagePort is not available"));
-            }
-        
-            const req: IRequest = {
-                requestId: /* Create a random ID with the function of your choice */,
-                senderId: this.senderId,
-                ...request,
-            };
-        
-            this.pendingRequests.set(req.requestId, {
-                resolve: (response: IResponse<T>) => (response.status < 400)
-                    ? resolve(response.body as T)
-                    : reject(response);
-                reject: (response?: IResponse<T>) => reject(response),
-                request: req,
-            });
-        
-            this.port.postMessage(req);
-        });
+    public batch$<T = IBatchResponsePayload>(requests: Omit<IBatchRequestItem<unknown>, 'requestId'>[]): Observable<T> {
+        return from(this.batch(requests) as Promise<T>);
     }
 }
-```
 
-Use it like that :
+// Somewhere during app bootstrap
+await noxusService.init();
 
-```ts
-const response: User[] = await electronService.request<User[]>({
-    method: 'GET',
-    path: 'users/all',
+// Subscribe to push notifications
+const subscription = noxusService.events.subscribe('users.updated', (payload) => {
+    console.log('Users updated:', payload);
 });
 ```
 
+If you need a custom bridge (for example a different preload shape), pass it via the constructor: `super({ bridge: window.customBridge })`. The class keeps promise-based semantics so frameworks can layer their own reactive wrappers as shown above.
+
 ![Startup image](./images/screenshot-requests.png)
 
 
@@ -354,7 +263,7 @@ If you throw any of these exception, the response to the renderer will contains
 
 You can specify a message in the constructor.
 
-You throw it as follow : 
+You throw it as follow :
 ```ts
 throw new UnauthorizedException("Invalid credentials");
 throw new BadRequestException("id is missing in the body");

package/dist/{index-5OkVPHfI.d.mts → index-CI3OMzNR.d.mts}

@@ -176,13 +176,14 @@ declare const RootInjector: 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, id: string, method: HttpMethod, path: string, body: any);
+    constructor(event: Electron.MessageEvent, senderId: number, id: string, method: HttpMethod, path: string, body: any);
 }
 /**
  * The IRequest interface defines the structure of a request object.
@@ -265,4 +266,53 @@ declare class RendererEventRegistry {
     hasHandlers(eventName: string): boolean;
 }
 
-export { AppInjector as A, Delete as D, Get as G, type HttpMethod as H, type IResponse as I, type Lifetime as L, type MaybeAsync as M, Post as P, Request as R, type Type as T, type IGuard as a, type IBinding as b, RootInjector as c, Authorize as d, getGuardForControllerAction as e, type IRouteMetadata as f, getGuardForController as g, type AtomicHttpMethod as h, inject as i, getRouteMetadata as j, Put as k, Patch as l, ROUTE_METADATA_KEY as m, type IRequest as n, type IBatchRequestItem as o, type IBatchRequestPayload as p, type IBatchResponsePayload as q, RENDERER_EVENT_TYPE as r, type IRendererEventMessage as s, createRendererEventMessage as t, isRendererEventMessage as u, type RendererEventHandler as v, type RendererEventSubscription as w, RendererEventRegistry as x };
+
+interface IPortRequester {
+    requestPort(): void;
+}
+interface RendererClientOptions {
+    bridge?: IPortRequester | null;
+    bridgeName?: string | string[];
+    initMessageType?: string;
+    windowRef?: Window;
+    generateRequestId?: () => string;
+}
+interface PendingRequest<T = unknown> {
+    resolve: (value: T) => void;
+    reject: (reason: IResponse<T>) => void;
+    request: IRequest;
+    submittedAt: number;
+}
+declare class NoxRendererClient {
+    readonly events: RendererEventRegistry;
+    protected readonly pendingRequests: Map<string, PendingRequest<unknown>>;
+    protected requestPort: MessagePort | undefined;
+    protected socketPort: MessagePort | undefined;
+    protected senderId: number | undefined;
+    private readonly bridge;
+    private readonly initMessageType;
+    private readonly windowRef;
+    private readonly generateRequestId;
+    private isReady;
+    private setupPromise;
+    private setupResolve;
+    private setupReject;
+    constructor(options?: RendererClientOptions);
+    setup(): Promise<void>;
+    dispose(): void;
+    request<TResponse, TBody = unknown>(request: Omit<IRequest<TBody>, 'requestId' | 'senderId'>): Promise<TResponse>;
+    batch(requests: Omit<IBatchRequestItem<unknown>, 'requestId'>[]): Promise<IBatchResponsePayload>;
+    getSenderId(): number | undefined;
+    private readonly onWindowMessage;
+    private readonly onSocketMessage;
+    private readonly onRequestMessage;
+    protected onRequestCompleted(pending: PendingRequest, response: IResponse): void;
+    private attachRequestPort;
+    private attachSocketPort;
+    private validateReady;
+    private createErrorResponse;
+    private resetSetupState;
+    isElectronEnvironment(): boolean;
+}
+
+export { AppInjector as A, Delete as D, Get as G, type HttpMethod as H, type IResponse as I, type Lifetime as L, type MaybeAsync as M, NoxRendererClient as N, Post as P, Request as R, type Type as T, type IGuard as a, type IPortRequester as b, type IBinding as c, RootInjector as d, Authorize as e, getGuardForControllerAction as f, getGuardForController as g, type IRouteMetadata as h, inject as i, type AtomicHttpMethod as j, getRouteMetadata as k, Put as l, Patch as m, ROUTE_METADATA_KEY as n, type IRequest as o, type IBatchRequestItem as p, type IBatchRequestPayload as q, type IBatchResponsePayload as r, RENDERER_EVENT_TYPE as s, type IRendererEventMessage as t, createRendererEventMessage as u, isRendererEventMessage as v, type RendererEventHandler as w, type RendererEventSubscription as x, RendererEventRegistry as y, type RendererClientOptions as z };

package/dist/{index-5OkVPHfI.d.ts → index-CI3OMzNR.d.ts}

@@ -176,13 +176,14 @@ declare const RootInjector: 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, id: string, method: HttpMethod, path: string, body: any);
+    constructor(event: Electron.MessageEvent, senderId: number, id: string, method: HttpMethod, path: string, body: any);
 }
 /**
  * The IRequest interface defines the structure of a request object.
@@ -265,4 +266,53 @@ declare class RendererEventRegistry {
     hasHandlers(eventName: string): boolean;
 }
 
-export { AppInjector as A, Delete as D, Get as G, type HttpMethod as H, type IResponse as I, type Lifetime as L, type MaybeAsync as M, Post as P, Request as R, type Type as T, type IGuard as a, type IBinding as b, RootInjector as c, Authorize as d, getGuardForControllerAction as e, type IRouteMetadata as f, getGuardForController as g, type AtomicHttpMethod as h, inject as i, getRouteMetadata as j, Put as k, Patch as l, ROUTE_METADATA_KEY as m, type IRequest as n, type IBatchRequestItem as o, type IBatchRequestPayload as p, type IBatchResponsePayload as q, RENDERER_EVENT_TYPE as r, type IRendererEventMessage as s, createRendererEventMessage as t, isRendererEventMessage as u, type RendererEventHandler as v, type RendererEventSubscription as w, RendererEventRegistry as x };
+
+interface IPortRequester {
+    requestPort(): void;
+}
+interface RendererClientOptions {
+    bridge?: IPortRequester | null;
+    bridgeName?: string | string[];
+    initMessageType?: string;
+    windowRef?: Window;
+    generateRequestId?: () => string;
+}
+interface PendingRequest<T = unknown> {
+    resolve: (value: T) => void;
+    reject: (reason: IResponse<T>) => void;
+    request: IRequest;
+    submittedAt: number;
+}
+declare class NoxRendererClient {
+    readonly events: RendererEventRegistry;
+    protected readonly pendingRequests: Map<string, PendingRequest<unknown>>;
+    protected requestPort: MessagePort | undefined;
+    protected socketPort: MessagePort | undefined;
+    protected senderId: number | undefined;
+    private readonly bridge;
+    private readonly initMessageType;
+    private readonly windowRef;
+    private readonly generateRequestId;
+    private isReady;
+    private setupPromise;
+    private setupResolve;
+    private setupReject;
+    constructor(options?: RendererClientOptions);
+    setup(): Promise<void>;
+    dispose(): void;
+    request<TResponse, TBody = unknown>(request: Omit<IRequest<TBody>, 'requestId' | 'senderId'>): Promise<TResponse>;
+    batch(requests: Omit<IBatchRequestItem<unknown>, 'requestId'>[]): Promise<IBatchResponsePayload>;
+    getSenderId(): number | undefined;
+    private readonly onWindowMessage;
+    private readonly onSocketMessage;
+    private readonly onRequestMessage;
+    protected onRequestCompleted(pending: PendingRequest, response: IResponse): void;
+    private attachRequestPort;
+    private attachSocketPort;
+    private validateReady;
+    private createErrorResponse;
+    private resetSetupState;
+    isElectronEnvironment(): boolean;
+}
+
+export { AppInjector as A, Delete as D, Get as G, type HttpMethod as H, type IResponse as I, type Lifetime as L, type MaybeAsync as M, NoxRendererClient as N, Post as P, Request as R, type Type as T, type IGuard as a, type IPortRequester as b, type IBinding as c, RootInjector as d, Authorize as e, getGuardForControllerAction as f, getGuardForController as g, type IRouteMetadata as h, inject as i, type AtomicHttpMethod as j, getRouteMetadata as k, Put as l, Patch as m, ROUTE_METADATA_KEY as n, type IRequest as o, type IBatchRequestItem as p, type IBatchRequestPayload as q, type IBatchResponsePayload as r, RENDERER_EVENT_TYPE as s, type IRendererEventMessage as t, createRendererEventMessage as u, isRendererEventMessage as v, type RendererEventHandler as w, type RendererEventSubscription as x, RendererEventRegistry as y, type RendererClientOptions as z };

package/dist/main.d.mts

@@ -1,5 +1,5 @@
-import { R as Request, I as IResponse, M as MaybeAsync, T as Type, a as IGuard, L as Lifetime } from './index-5OkVPHfI.mjs';
-export { A as AppInjector, h as AtomicHttpMethod, d as Authorize, D as Delete, G as Get, H as HttpMethod, o as IBatchRequestItem, p as IBatchRequestPayload, q as IBatchResponsePayload, b as IBinding, s as IRendererEventMessage, n as IRequest, f as IRouteMetadata, l as Patch, P as Post, k as Put, r as RENDERER_EVENT_TYPE, m as ROUTE_METADATA_KEY, v as RendererEventHandler, x as RendererEventRegistry, w as RendererEventSubscription, c as RootInjector, t as createRendererEventMessage, g as getGuardForController, e as getGuardForControllerAction, j as getRouteMetadata, i as inject, u as isRendererEventMessage } from './index-5OkVPHfI.mjs';
+import { R as Request, I as IResponse, M as MaybeAsync, T as Type, a as IGuard, L as Lifetime, b as IPortRequester } from './index-CI3OMzNR.mjs';
+export { A as AppInjector, j as AtomicHttpMethod, e as Authorize, D as Delete, G as Get, H as HttpMethod, p as IBatchRequestItem, q as IBatchRequestPayload, r as IBatchResponsePayload, c as IBinding, t as IRendererEventMessage, o as IRequest, h as IRouteMetadata, N as NoxRendererClient, m as Patch, P as Post, l as Put, s as RENDERER_EVENT_TYPE, n as ROUTE_METADATA_KEY, z as RendererClientOptions, w as RendererEventHandler, y as RendererEventRegistry, x as RendererEventSubscription, d as RootInjector, u as createRendererEventMessage, g as getGuardForController, f as getGuardForControllerAction, k as getRouteMetadata, i as inject, v as isRendererEventMessage } from './index-CI3OMzNR.mjs';
 
 /**
  * @copyright 2025 NoxFly
@@ -160,10 +160,14 @@ declare class Router {
     private extractParams;
 }
 
+interface RendererChannels {
+    request: Electron.MessageChannelMain;
+    socket: Electron.MessageChannelMain;
+}
 declare class NoxSocket {
-    private readonly messagePorts;
-    register(senderId: number, channel: Electron.MessageChannelMain): void;
-    get(senderId: number): Electron.MessageChannelMain | undefined;
+    private readonly channels;
+    register(senderId: number, requestChannel: Electron.MessageChannelMain, socketChannel: Electron.MessageChannelMain): void;
+    get(senderId: number): RendererChannels | undefined;
     unregister(senderId: number): void;
     getSenderIds(): number[];
     emit<TPayload = unknown>(eventName: string, payload?: TPayload, targetSenderIds?: number[]): number;
@@ -189,6 +193,9 @@ declare class NoxApp {
     private readonly router;
     private readonly socket;
     private app;
+    /**
+     *
+     */
     private readonly onRendererMessage;
     constructor(router: Router, socket: NoxSocket);
     /**
@@ -352,6 +359,10 @@ declare function Controller(path: string): ClassDecorator;
 declare function getControllerMetadata(target: Type<unknown>): IControllerMetadata | undefined;
 declare const CONTROLLER_METADATA_KEY: unique symbol;
 
+declare const INJECTABLE_METADATA_KEY: unique symbol;
+declare function getInjectableMetadata(target: Function): Lifetime | undefined;
+declare function hasInjectableMetadata(target: Function): boolean;
+
 
 /**
  * The Injectable decorator marks a class as injectable.
@@ -361,14 +372,6 @@ declare const CONTROLLER_METADATA_KEY: unique symbol;
  * @param lifetime - The lifetime of the injectable. Can be 'singleton', 'scope', or 'transient'.
  */
 declare function Injectable(lifetime?: Lifetime): ClassDecorator;
-/**
- * Gets the injectable metadata for a given target class.
- * This metadata includes the lifetime of the injectable defined by the @Injectable decorator.
- * @param target - The target class to get the injectable metadata from.
- * @returns The lifetime of the injectable if it exists, otherwise undefined.
- */
-declare function getInjectableMetadata(target: Type<unknown>): Lifetime | undefined;
-declare const INJECTABLE_METADATA_KEY: unique symbol;
 
 
 interface IModuleMetadata {
@@ -387,6 +390,23 @@ declare function Module(metadata: IModuleMetadata): ClassDecorator;
 declare function getModuleMetadata(target: Function): IModuleMetadata | undefined;
 declare const MODULE_METADATA_KEY: unique symbol;
 
+
+interface NoxusPreloadAPI extends IPortRequester {
+}
+interface NoxusPreloadOptions {
+    exposeAs?: string;
+    initMessageType?: string;
+    requestChannel?: string;
+    responseChannel?: string;
+    targetWindow?: Window;
+}
+/**
+ * Exposes a minimal bridge in the isolated preload context so renderer processes
+ * can request the two MessagePorts required by Noxus. The bridge forwards both
+ * request/response and socket ports to the renderer via window.postMessage.
+ */
+declare function exposeNoxusBridge(options?: NoxusPreloadOptions): NoxusPreloadAPI;
+
 /**
  * Logger is a utility class for logging messages to the console.
  */
@@ -462,4 +482,4 @@ declare namespace Logger {
     };
 }
 
-export { BadGatewayException, BadRequestException, CONTROLLER_METADATA_KEY, ConflictException, Controller, type ControllerAction, ForbiddenException, GatewayTimeoutException, HttpVersionNotSupportedException, type IApp, type IControllerMetadata, IGuard, type IMiddleware, type IModuleMetadata, INJECTABLE_METADATA_KEY, IResponse, type IRouteDefinition, Injectable, InsufficientStorageException, InternalServerException, Lifetime, type LogLevel, Logger, LoopDetectedException, MODULE_METADATA_KEY, MaybeAsync, MethodNotAllowedException, Module, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, type NextFunction, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, NoxApp, NoxSocket, PaymentRequiredException, Request, RequestTimeoutException, ResponseException, Router, ServiceUnavailableException, TooManyRequestsException, Type, UnauthorizedException, UpgradeRequiredException, UseMiddlewares, VariantAlsoNegotiatesException, bootstrapApplication, getControllerMetadata, getInjectableMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata };
+export { BadGatewayException, BadRequestException, CONTROLLER_METADATA_KEY, ConflictException, Controller, type ControllerAction, ForbiddenException, GatewayTimeoutException, HttpVersionNotSupportedException, type IApp, type IControllerMetadata, IGuard, type IMiddleware, type IModuleMetadata, INJECTABLE_METADATA_KEY, IPortRequester, IResponse, type IRouteDefinition, Injectable, InsufficientStorageException, InternalServerException, Lifetime, type LogLevel, Logger, LoopDetectedException, MODULE_METADATA_KEY, MaybeAsync, MethodNotAllowedException, Module, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, type NextFunction, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, NoxApp, NoxSocket, type NoxusPreloadAPI, type NoxusPreloadOptions, PaymentRequiredException, Request, RequestTimeoutException, ResponseException, Router, ServiceUnavailableException, TooManyRequestsException, Type, UnauthorizedException, UpgradeRequiredException, UseMiddlewares, VariantAlsoNegotiatesException, bootstrapApplication, exposeNoxusBridge, getControllerMetadata, getInjectableMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata, hasInjectableMetadata };

package/dist/main.d.ts

@@ -1,5 +1,5 @@
-import { R as Request, I as IResponse, M as MaybeAsync, T as Type, a as IGuard, L as Lifetime } from './index-5OkVPHfI.js';
-export { A as AppInjector, h as AtomicHttpMethod, d as Authorize, D as Delete, G as Get, H as HttpMethod, o as IBatchRequestItem, p as IBatchRequestPayload, q as IBatchResponsePayload, b as IBinding, s as IRendererEventMessage, n as IRequest, f as IRouteMetadata, l as Patch, P as Post, k as Put, r as RENDERER_EVENT_TYPE, m as ROUTE_METADATA_KEY, v as RendererEventHandler, x as RendererEventRegistry, w as RendererEventSubscription, c as RootInjector, t as createRendererEventMessage, g as getGuardForController, e as getGuardForControllerAction, j as getRouteMetadata, i as inject, u as isRendererEventMessage } from './index-5OkVPHfI.js';
+import { R as Request, I as IResponse, M as MaybeAsync, T as Type, a as IGuard, L as Lifetime, b as IPortRequester } from './index-CI3OMzNR.js';
+export { A as AppInjector, j as AtomicHttpMethod, e as Authorize, D as Delete, G as Get, H as HttpMethod, p as IBatchRequestItem, q as IBatchRequestPayload, r as IBatchResponsePayload, c as IBinding, t as IRendererEventMessage, o as IRequest, h as IRouteMetadata, N as NoxRendererClient, m as Patch, P as Post, l as Put, s as RENDERER_EVENT_TYPE, n as ROUTE_METADATA_KEY, z as RendererClientOptions, w as RendererEventHandler, y as RendererEventRegistry, x as RendererEventSubscription, d as RootInjector, u as createRendererEventMessage, g as getGuardForController, f as getGuardForControllerAction, k as getRouteMetadata, i as inject, v as isRendererEventMessage } from './index-CI3OMzNR.js';
 
 /**
  * @copyright 2025 NoxFly
@@ -160,10 +160,14 @@ declare class Router {
     private extractParams;
 }
 
+interface RendererChannels {
+    request: Electron.MessageChannelMain;
+    socket: Electron.MessageChannelMain;
+}
 declare class NoxSocket {
-    private readonly messagePorts;
-    register(senderId: number, channel: Electron.MessageChannelMain): void;
-    get(senderId: number): Electron.MessageChannelMain | undefined;
+    private readonly channels;
+    register(senderId: number, requestChannel: Electron.MessageChannelMain, socketChannel: Electron.MessageChannelMain): void;
+    get(senderId: number): RendererChannels | undefined;
     unregister(senderId: number): void;
     getSenderIds(): number[];
     emit<TPayload = unknown>(eventName: string, payload?: TPayload, targetSenderIds?: number[]): number;
@@ -189,6 +193,9 @@ declare class NoxApp {
     private readonly router;
     private readonly socket;
     private app;
+    /**
+     *
+     */
     private readonly onRendererMessage;
     constructor(router: Router, socket: NoxSocket);
     /**
@@ -352,6 +359,10 @@ declare function Controller(path: string): ClassDecorator;
 declare function getControllerMetadata(target: Type<unknown>): IControllerMetadata | undefined;
 declare const CONTROLLER_METADATA_KEY: unique symbol;
 
+declare const INJECTABLE_METADATA_KEY: unique symbol;
+declare function getInjectableMetadata(target: Function): Lifetime | undefined;
+declare function hasInjectableMetadata(target: Function): boolean;
+
 
 /**
  * The Injectable decorator marks a class as injectable.
@@ -361,14 +372,6 @@ declare const CONTROLLER_METADATA_KEY: unique symbol;
  * @param lifetime - The lifetime of the injectable. Can be 'singleton', 'scope', or 'transient'.
  */
 declare function Injectable(lifetime?: Lifetime): ClassDecorator;
-/**
- * Gets the injectable metadata for a given target class.
- * This metadata includes the lifetime of the injectable defined by the @Injectable decorator.
- * @param target - The target class to get the injectable metadata from.
- * @returns The lifetime of the injectable if it exists, otherwise undefined.
- */
-declare function getInjectableMetadata(target: Type<unknown>): Lifetime | undefined;
-declare const INJECTABLE_METADATA_KEY: unique symbol;
 
 
 interface IModuleMetadata {
@@ -387,6 +390,23 @@ declare function Module(metadata: IModuleMetadata): ClassDecorator;
 declare function getModuleMetadata(target: Function): IModuleMetadata | undefined;
 declare const MODULE_METADATA_KEY: unique symbol;
 
+
+interface NoxusPreloadAPI extends IPortRequester {
+}
+interface NoxusPreloadOptions {
+    exposeAs?: string;
+    initMessageType?: string;
+    requestChannel?: string;
+    responseChannel?: string;
+    targetWindow?: Window;
+}
+/**
+ * Exposes a minimal bridge in the isolated preload context so renderer processes
+ * can request the two MessagePorts required by Noxus. The bridge forwards both
+ * request/response and socket ports to the renderer via window.postMessage.
+ */
+declare function exposeNoxusBridge(options?: NoxusPreloadOptions): NoxusPreloadAPI;
+
 /**
  * Logger is a utility class for logging messages to the console.
  */
@@ -462,4 +482,4 @@ declare namespace Logger {
     };
 }
 
-export { BadGatewayException, BadRequestException, CONTROLLER_METADATA_KEY, ConflictException, Controller, type ControllerAction, ForbiddenException, GatewayTimeoutException, HttpVersionNotSupportedException, type IApp, type IControllerMetadata, IGuard, type IMiddleware, type IModuleMetadata, INJECTABLE_METADATA_KEY, IResponse, type IRouteDefinition, Injectable, InsufficientStorageException, InternalServerException, Lifetime, type LogLevel, Logger, LoopDetectedException, MODULE_METADATA_KEY, MaybeAsync, MethodNotAllowedException, Module, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, type NextFunction, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, NoxApp, NoxSocket, PaymentRequiredException, Request, RequestTimeoutException, ResponseException, Router, ServiceUnavailableException, TooManyRequestsException, Type, UnauthorizedException, UpgradeRequiredException, UseMiddlewares, VariantAlsoNegotiatesException, bootstrapApplication, getControllerMetadata, getInjectableMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata };
+export { BadGatewayException, BadRequestException, CONTROLLER_METADATA_KEY, ConflictException, Controller, type ControllerAction, ForbiddenException, GatewayTimeoutException, HttpVersionNotSupportedException, type IApp, type IControllerMetadata, IGuard, type IMiddleware, type IModuleMetadata, INJECTABLE_METADATA_KEY, IPortRequester, IResponse, type IRouteDefinition, Injectable, InsufficientStorageException, InternalServerException, Lifetime, type LogLevel, Logger, LoopDetectedException, MODULE_METADATA_KEY, MaybeAsync, MethodNotAllowedException, Module, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, type NextFunction, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, NoxApp, NoxSocket, type NoxusPreloadAPI, type NoxusPreloadOptions, PaymentRequiredException, Request, RequestTimeoutException, ResponseException, Router, ServiceUnavailableException, TooManyRequestsException, Type, UnauthorizedException, UpgradeRequiredException, UseMiddlewares, VariantAlsoNegotiatesException, bootstrapApplication, exposeNoxusBridge, getControllerMetadata, getInjectableMetadata, getMiddlewaresForController, getMiddlewaresForControllerAction, getModuleMetadata, hasInjectableMetadata };