@noxfly/noxus 2.4.0 → 2.5.0

package/dist/renderer.d.mts

@@ -1,2 +1,113 @@
-export { e as AtomicHttpMethod, H as HttpMethod, l as IBatchRequestItem, m as IBatchRequestPayload, n as IBatchResponsePayload, b as IPortRequester, p as IRendererEventMessage, k as IRequest, I as IResponse, N as NoxRendererClient, o as RENDERER_EVENT_TYPE, v as RendererClientOptions, s as RendererEventHandler, u as RendererEventRegistry, t as RendererEventSubscription, R as Request, q as createRendererEventMessage, r as isRendererEventMessage } from './index-DQBQQfMw.mjs';
+import { I as IRendererEventMessage, a as IResponse, b as IRequest, c as IBatchRequestItem, d as IBatchResponsePayload } from './request-Dx_5Prte.mjs';
+export { A as AtomicHttpMethod, H as HttpMethod, e as IBatchRequestPayload, f as RENDERER_EVENT_TYPE, R as Request, g as createRendererEventMessage, i as isRendererEventMessage } from './request-Dx_5Prte.mjs';
 import './app-injector-B3MvgV3k.mjs';
+
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+/**
+ * Lightweight event registry to help renderer processes subscribe to
+ * push messages sent by the main process through Noxus.
+ */
+
+type RendererEventHandler<TPayload = unknown> = (payload: TPayload) => void;
+interface RendererEventSubscription {
+    unsubscribe(): void;
+}
+declare class RendererEventRegistry {
+    private readonly listeners;
+    /**
+     *
+     */
+    subscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): RendererEventSubscription;
+    /**
+     *
+     */
+    unsubscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): void;
+    /**
+     *
+     */
+    clear(eventName?: string): void;
+    /**
+     *
+     */
+    dispatch<TPayload>(message: IRendererEventMessage<TPayload>): void;
+    /**
+     *
+     */
+    tryDispatchFromMessageEvent(event: MessageEvent): boolean;
+    /**
+     *
+     */
+    hasHandlers(eventName: string): boolean;
+}
+
+
+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;
+}
+
+
+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;
+
+export { IBatchRequestItem, IBatchResponsePayload, type IPortRequester, IRendererEventMessage, IRequest, IResponse, NoxRendererClient, type NoxusPreloadAPI, type NoxusPreloadOptions, type RendererClientOptions, type RendererEventHandler, RendererEventRegistry, type RendererEventSubscription, exposeNoxusBridge };

package/dist/renderer.d.ts

@@ -1,2 +1,113 @@
-export { e as AtomicHttpMethod, H as HttpMethod, l as IBatchRequestItem, m as IBatchRequestPayload, n as IBatchResponsePayload, b as IPortRequester, p as IRendererEventMessage, k as IRequest, I as IResponse, N as NoxRendererClient, o as RENDERER_EVENT_TYPE, v as RendererClientOptions, s as RendererEventHandler, u as RendererEventRegistry, t as RendererEventSubscription, R as Request, q as createRendererEventMessage, r as isRendererEventMessage } from './index-BxWQVi6C.js';
+import { I as IRendererEventMessage, a as IResponse, b as IRequest, c as IBatchRequestItem, d as IBatchResponsePayload } from './request-CdpZ9qZL.js';
+export { A as AtomicHttpMethod, H as HttpMethod, e as IBatchRequestPayload, f as RENDERER_EVENT_TYPE, R as Request, g as createRendererEventMessage, i as isRendererEventMessage } from './request-CdpZ9qZL.js';
 import './app-injector-B3MvgV3k.js';
+
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+/**
+ * Lightweight event registry to help renderer processes subscribe to
+ * push messages sent by the main process through Noxus.
+ */
+
+type RendererEventHandler<TPayload = unknown> = (payload: TPayload) => void;
+interface RendererEventSubscription {
+    unsubscribe(): void;
+}
+declare class RendererEventRegistry {
+    private readonly listeners;
+    /**
+     *
+     */
+    subscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): RendererEventSubscription;
+    /**
+     *
+     */
+    unsubscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): void;
+    /**
+     *
+     */
+    clear(eventName?: string): void;
+    /**
+     *
+     */
+    dispatch<TPayload>(message: IRendererEventMessage<TPayload>): void;
+    /**
+     *
+     */
+    tryDispatchFromMessageEvent(event: MessageEvent): boolean;
+    /**
+     *
+     */
+    hasHandlers(eventName: string): boolean;
+}
+
+
+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;
+}
+
+
+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;
+
+export { IBatchRequestItem, IBatchResponsePayload, type IPortRequester, IRendererEventMessage, IRequest, IResponse, NoxRendererClient, type NoxusPreloadAPI, type NoxusPreloadOptions, type RendererClientOptions, type RendererEventHandler, RendererEventRegistry, type RendererEventSubscription, exposeNoxusBridge };

package/dist/renderer.js

@@ -33,6 +33,7 @@ __export(src_exports, {
   RendererEventRegistry: () => RendererEventRegistry,
   Request: () => Request,
   createRendererEventMessage: () => createRendererEventMessage,
+  exposeNoxusBridge: () => exposeNoxusBridge,
   isRendererEventMessage: () => isRendererEventMessage
 });
 module.exports = __toCommonJS(src_exports);
@@ -217,6 +218,42 @@ function isRendererEventMessage(value) {
 }
 __name(isRendererEventMessage, "isRendererEventMessage");
 
+// src/preload-bridge.ts
+var import_renderer = require("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(() => {
+      import_renderer.ipcRenderer.send(requestChannel);
+      import_renderer.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")
+  };
+  import_renderer.contextBridge.exposeInMainWorld(exposeAs, api);
+  return api;
+}
+__name(exposeNoxusBridge, "exposeNoxusBridge");
+
 // src/renderer-events.ts
 var _RendererEventRegistry = class _RendererEventRegistry {
   constructor() {
@@ -298,7 +335,7 @@ __name(_RendererEventRegistry, "RendererEventRegistry");
 var RendererEventRegistry = _RendererEventRegistry;
 
 // src/renderer-client.ts
-var DEFAULT_INIT_EVENT = "init-port";
+var DEFAULT_INIT_EVENT2 = "init-port";
 var DEFAULT_BRIDGE_NAMES = [
   "noxus",
   "ipcRenderer"
@@ -420,7 +457,7 @@ var _NoxRendererClient = class _NoxRendererClient {
     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() {
@@ -549,6 +586,7 @@ var NoxRendererClient = _NoxRendererClient;
   RendererEventRegistry,
   Request,
   createRendererEventMessage,
+  exposeNoxusBridge,
   isRendererEventMessage
 });
 /**

package/dist/renderer.mjs

@@ -188,6 +188,42 @@ 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() {
@@ -269,7 +305,7 @@ __name(_RendererEventRegistry, "RendererEventRegistry");
 var RendererEventRegistry = _RendererEventRegistry;
 
 // src/renderer-client.ts
-var DEFAULT_INIT_EVENT = "init-port";
+var DEFAULT_INIT_EVENT2 = "init-port";
 var DEFAULT_BRIDGE_NAMES = [
   "noxus",
   "ipcRenderer"
@@ -391,7 +427,7 @@ var _NoxRendererClient = class _NoxRendererClient {
     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 +555,7 @@ export {
   RendererEventRegistry,
   Request,
   createRendererEventMessage,
+  exposeNoxusBridge,
   isRendererEventMessage
 };
 /**

package/dist/{index-BxWQVi6C.d.ts → request-CdpZ9qZL.d.ts}

@@ -164,90 +164,4 @@ interface IRendererEventMessage<TPayload = unknown> {
 declare function createRendererEventMessage<TPayload = unknown>(event: string, payload?: TPayload): IRendererEventMessage<TPayload>;
 declare function isRendererEventMessage(value: unknown): value is IRendererEventMessage;
 
-/**
- * Lightweight event registry to help renderer processes subscribe to
- * push messages sent by the main process through Noxus.
- */
-
-type RendererEventHandler<TPayload = unknown> = (payload: TPayload) => void;
-interface RendererEventSubscription {
-    unsubscribe(): void;
-}
-declare class RendererEventRegistry {
-    private readonly listeners;
-    /**
-     *
-     */
-    subscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): RendererEventSubscription;
-    /**
-     *
-     */
-    unsubscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): void;
-    /**
-     *
-     */
-    clear(eventName?: string): void;
-    /**
-     *
-     */
-    dispatch<TPayload>(message: IRendererEventMessage<TPayload>): void;
-    /**
-     *
-     */
-    tryDispatchFromMessageEvent(event: MessageEvent): boolean;
-    /**
-     *
-     */
-    hasHandlers(eventName: string): boolean;
-}
-
-
-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 { Authorize as A, Delete as D, Get as G, type HttpMethod as H, type IResponse as I, NoxRendererClient as N, Post as P, Request as R, type IGuard as a, type IPortRequester as b, getGuardForControllerAction as c, type IRouteMetadata as d, type AtomicHttpMethod as e, getRouteMetadata as f, getGuardForController as g, Put as h, Patch as i, ROUTE_METADATA_KEY as j, type IRequest as k, type IBatchRequestItem as l, type IBatchRequestPayload as m, type IBatchResponsePayload as n, RENDERER_EVENT_TYPE as o, type IRendererEventMessage as p, createRendererEventMessage as q, isRendererEventMessage as r, type RendererEventHandler as s, type RendererEventSubscription as t, RendererEventRegistry as u, type RendererClientOptions as v };
+export { type AtomicHttpMethod as A, Delete as D, Get as G, type HttpMethod as H, type IRendererEventMessage as I, Post as P, Request as R, type IResponse as a, type IRequest as b, type IBatchRequestItem as c, type IBatchResponsePayload as d, type IBatchRequestPayload as e, RENDERER_EVENT_TYPE as f, createRendererEventMessage as g, type IGuard as h, isRendererEventMessage as i, Authorize as j, getGuardForController as k, getGuardForControllerAction as l, type IRouteMetadata as m, getRouteMetadata as n, Put as o, Patch as p, ROUTE_METADATA_KEY as q };

package/dist/{index-DQBQQfMw.d.mts → request-Dx_5Prte.d.mts}

@@ -164,90 +164,4 @@ interface IRendererEventMessage<TPayload = unknown> {
 declare function createRendererEventMessage<TPayload = unknown>(event: string, payload?: TPayload): IRendererEventMessage<TPayload>;
 declare function isRendererEventMessage(value: unknown): value is IRendererEventMessage;
 
-/**
- * Lightweight event registry to help renderer processes subscribe to
- * push messages sent by the main process through Noxus.
- */
-
-type RendererEventHandler<TPayload = unknown> = (payload: TPayload) => void;
-interface RendererEventSubscription {
-    unsubscribe(): void;
-}
-declare class RendererEventRegistry {
-    private readonly listeners;
-    /**
-     *
-     */
-    subscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): RendererEventSubscription;
-    /**
-     *
-     */
-    unsubscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): void;
-    /**
-     *
-     */
-    clear(eventName?: string): void;
-    /**
-     *
-     */
-    dispatch<TPayload>(message: IRendererEventMessage<TPayload>): void;
-    /**
-     *
-     */
-    tryDispatchFromMessageEvent(event: MessageEvent): boolean;
-    /**
-     *
-     */
-    hasHandlers(eventName: string): boolean;
-}
-
-
-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 { Authorize as A, Delete as D, Get as G, type HttpMethod as H, type IResponse as I, NoxRendererClient as N, Post as P, Request as R, type IGuard as a, type IPortRequester as b, getGuardForControllerAction as c, type IRouteMetadata as d, type AtomicHttpMethod as e, getRouteMetadata as f, getGuardForController as g, Put as h, Patch as i, ROUTE_METADATA_KEY as j, type IRequest as k, type IBatchRequestItem as l, type IBatchRequestPayload as m, type IBatchResponsePayload as n, RENDERER_EVENT_TYPE as o, type IRendererEventMessage as p, createRendererEventMessage as q, isRendererEventMessage as r, type RendererEventHandler as s, type RendererEventSubscription as t, RendererEventRegistry as u, type RendererClientOptions as v };
+export { type AtomicHttpMethod as A, Delete as D, Get as G, type HttpMethod as H, type IRendererEventMessage as I, Post as P, Request as R, type IResponse as a, type IRequest as b, type IBatchRequestItem as c, type IBatchResponsePayload as d, type IBatchRequestPayload as e, RENDERER_EVENT_TYPE as f, createRendererEventMessage as g, type IGuard as h, isRendererEventMessage as i, Authorize as j, getGuardForController as k, getGuardForControllerAction as l, type IRouteMetadata as m, getRouteMetadata as n, Put as o, Patch as p, ROUTE_METADATA_KEY as q };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@noxfly/noxus",
-    "version": "2.4.0",
+    "version": "2.5.0",
     "main": "dist/main.js",
     "module": "dist/main.mjs",
     "types": "dist/main.d.ts",

package/src/DI/injector-explorer.ts

@@ -26,17 +26,23 @@ interface PendingRegistration {
 export class InjectorExplorer {
     private static readonly pending: PendingRegistration[] = [];
     private static processed = false;
+    private static accumulating = false;
 
     /**
      * Enqueues a class for deferred registration.
      * Called by the @Injectable decorator at import time.
      *
-     * If {@link processPending} has already been called (i.e. after bootstrap),
-     * the class is registered immediately so that late dynamic imports
-     * (e.g. middlewares loaded after bootstrap) work correctly.
+     * If {@link processPending} has already been called (i.e. after bootstrap)
+     * and accumulation mode is not active, the class is registered immediately
+     * so that late dynamic imports (e.g. middlewares loaded after bootstrap)
+     * work correctly.
+     *
+     * When accumulation mode is active (between {@link beginAccumulate} and
+     * {@link flushAccumulated}), classes are queued instead — preserving the
+     * two-phase binding/resolution guarantee for lazy-loaded modules.
      */
     public static enqueue(target: Type<unknown>, lifetime: Lifetime): void {
-        if(InjectorExplorer.processed) {
+        if(InjectorExplorer.processed && !InjectorExplorer.accumulating) {
             InjectorExplorer.registerImmediate(target, lifetime);
             return;
         }
@@ -44,6 +50,45 @@ export class InjectorExplorer {
         InjectorExplorer.pending.push({ target, lifetime });
     }
 
+    /**
+     * Enters accumulation mode. While active, all decorated classes discovered
+     * via dynamic imports are queued in {@link pending} rather than registered
+     * immediately. Call {@link flushAccumulated} to process them with the
+     * full two-phase (bind-then-resolve) guarantee.
+     */
+    public static beginAccumulate(): void {
+        InjectorExplorer.accumulating = true;
+    }
+
+    /**
+     * Exits accumulation mode and processes every class queued since
+     * {@link beginAccumulate} was called. Uses the same two-phase strategy
+     * as {@link processPending} (register all bindings first, then resolve
+     * singletons / controllers) so import ordering within a lazy batch
+     * does not cause resolution failures.
+     */
+    public static flushAccumulated(): void {
+        InjectorExplorer.accumulating = false;
+
+        const queue = [...InjectorExplorer.pending];
+        InjectorExplorer.pending.length = 0;
+
+        // Phase 1: register all bindings without instantiation
+        for(const { target, lifetime } of queue) {
+            if(!RootInjector.bindings.has(target)) {
+                RootInjector.bindings.set(target, {
+                    implementation: target,
+                    lifetime
+                });
+            }
+        }
+
+        // Phase 2: resolve singletons, register controllers, log modules
+        for(const { target, lifetime } of queue) {
+            InjectorExplorer.processRegistration(target, lifetime);
+        }
+    }
+
     /**
      * Processes all pending registrations in two phases:
      * 1. Register all bindings (no instantiation) so every dependency is known.