@irpclib/irpc 1.0.0-beta.22 → 1.0.0-beta.24

package/dist/module.d.ts

@@ -1,10 +1,17 @@
-import { IRPCCacher } from "./cache.js";
 import { IRPCTransport } from "./transport.js";
-import { IRPCData, IRPCDeclareInit, IRPCHandler, IRPCInputs, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCRequest, IRPCSpec, IRPCSpecStore, IRPCStubStore } from "./types.js";
+import { IRPCData, IRPCDeclareInit, IRPCFunction, IRPCHandler, IRPCInputs, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCRequest, IRPCSpec, IRPCStub } from "./types.js";
 import { RemoteState } from "./state.js";
+import { IRPCReader } from "./reader.js";
 
 //#region src/module.d.ts
-
+type IRPCHookArgs<F$1> = F$1 extends ((...args: infer A) => unknown) ? {
+  name: string;
+  args: A;
+} : {
+  name: string;
+  args: unknown[];
+};
+type IRPCSpecHook<F$1> = (req: IRPCHookArgs<F$1>) => void | Promise<void>;
 /**
  * IRPCPackage represents a package containing multiple IRPC (Isomorphic-RPC) specifications
  * and their corresponding stubs. It manages the configuration, transport, and execution
@@ -14,15 +21,16 @@ declare class IRPCPackage {
   /**
    * A map storing all IRPC specifications by their names
    */
-  specs: IRPCSpecStore;
+  private specs;
+  private hooks;
   /**
    * A weak map linking stub functions to their corresponding specifications
    */
-  stubs: IRPCStubStore;
+  private stubs;
   /**
    * A map storing caches for each IRPC Entry
    */
-  cache: WeakMap<Function, IRPCCacher>;
+  private cache;
   /**
    * Configuration object for the IRPC package
    */
@@ -51,7 +59,7 @@ declare class IRPCPackage {
    * @returns A stub function that can be used to call the IRPC
    * @throws Error if an IRPC with the same name already exists
    */
-  declare<F, I extends IRPCInputs = IRPCInputs, O extends IRPCOutput = IRPCOutput>(options: IRPCDeclareInit<F, I, O>): F;
+  declare<F, I extends IRPCInputs = IRPCInputs, O extends IRPCOutput = IRPCOutput>(options: IRPCDeclareInit<F, I, O>): IRPCFunction<F>;
   /**
    * Resolves and executes an IRPC call based on a request object
    * @param req - The request containing the IRPC name and arguments
@@ -66,7 +74,22 @@ declare class IRPCPackage {
    * @returns This IRPCPackage instance for chaining
    * @throws Error if the stub or handler is invalid, or if no IRPC exists for the stub
    */
-  construct<F extends IRPCHandler>(stub: F, handler: F): this;
+  construct<F, A extends unknown[], R extends IRPCData>(stub: IRPCStub<F, A, R>, handler: F): this;
+  /**
+   * Registers a hook function for a specific stub function
+   * @param stub - The stub function created by declare()
+   * @param handler - The hook function to register
+   * @returns This IRPCPackage instance for chaining
+   * @throws Error if the stub is invalid or if no IRPC exists for the stub
+   */
+  hook<F extends IRPCHandler>(stub: F, handler: IRPCSpecHook<F>): this;
+  /**
+   * Resolves and executes all registered hooks for a given request
+   * @param req - The request containing the IRPC name and arguments
+   * @returns A promise that resolves when all hooks have been executed
+   * @throws Error if no IRPC exists for the request or if the hooks are not registered
+   */
+  resolveHooks(req: IRPCRequest): Promise<void>;
   /**
    * Sets the transport mechanism for this package
    * @param transport - The transport instance to use for remote calls
@@ -100,5 +123,14 @@ declare class IRPCPackage {
  * @returns A new IRPCPackage instance
  */
 declare function createPackage(config?: Partial<IRPCPackageConfig>): IRPCPackage;
+/**
+ * Intercepts local function call to get an instant response without remote execution.
+ *
+ * @param reader - The reader object to intercept.
+ * @param spec - The IRPC specification for the function call.
+ * @param args - The arguments to be passed to the function.
+ * @returns {IRPCReader<IRPCData>} - The IRPCReader object for consumer.
+ */
+declare function intercept(spec: IRPCSpec<IRPCInputs, IRPCOutput>, args: unknown[], reader: IRPCReader<IRPCData>): IRPCReader<IRPCData>;
 //#endregion
-export { IRPCPackage, createPackage };
+export { IRPCHookArgs, IRPCPackage, IRPCSpecHook, createPackage, intercept };

package/dist/module.js

@@ -1,7 +1,12 @@
 import { IRPCCacher } from "./cache.js";
+import { IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { getAbortSignal } from "./context.js";
 import { RemoteState } from "./state.js";
+import { IRPCReader } from "./reader.js";
 import { IRPCTransport } from "./transport.js";
+import { IRPC_STORE } from "./store.js";
+import { anchor, createObserver, isBrowser, microtask, onCleanup, replay, uuid } from "@anchorlib/core";
 
 //#region src/module.ts
 const DEFAULT_TIMEOUT = 2e4;
@@ -17,6 +22,7 @@ var IRPCPackage = class {
 	* A map storing all IRPC specifications by their names
 	*/
 	specs = /* @__PURE__ */ new Map();
+	hooks = /* @__PURE__ */ new Map();
 	/**
 	* A weak map linking stub functions to their corresponding specifications
 	*/
@@ -63,6 +69,7 @@ var IRPCPackage = class {
 	*/
 	constructor(config) {
 		this.configure(config ?? {});
+		IRPC_STORE.register(this);
 	}
 	/**
 	* Declares a new IRPC specification and creates a corresponding stub function
@@ -71,17 +78,84 @@ var IRPCPackage = class {
 	* @throws Error if an IRPC with the same name already exists
 	*/
 	declare(options) {
-		if (this.specs.has(options.name)) throw new Error(`IRPC ${options.name} already exists.`);
-		const spec = { ...options };
+		const $options = options;
+		if (this.specs.has($options.name)) throw new Error(`IRPC ${$options.name} already exists.`);
+		const spec = {
+			init: () => void 0,
+			...$options
+		};
 		const calls = /* @__PURE__ */ new Map();
 		const caches = new IRPCCacher();
 		const stub = ((...args) => {
+			return execute(args, new IRPCReader(uuid(), spec.init()));
+		});
+		/** Browser only stub for single immediate execution **/
+		stub.once = (...args) => {
+			return prepare(() => args);
+		};
+		stub.with = (getArgs, debounce) => {
+			return prepare(typeof getArgs === "function" ? getArgs : () => getArgs, false, debounce);
+		};
+		stub.when = (getArgs, debounce) => {
+			return prepare(typeof getArgs === "function" ? getArgs : () => getArgs, true, debounce);
+		};
+		stub.later = (debounce) => {
+			const reader = new IRPCReader(uuid(), spec.init(), IRPC_STATUS.IDLE, true);
+			if (debounce) {
+				const [schedule, cancel] = microtask(debounce);
+				reader.dispatch = (...args) => schedule(() => {
+					reader.resume();
+					execute(args, reader);
+				});
+				onCleanup(cancel);
+				return reader;
+			}
+			reader.dispatch = (...args) => {
+				reader.resume();
+				execute(args, reader);
+			};
+			return reader;
+		};
+		/**
+		* A preparation utility to generate and schedule call on the browser environment.
+		*
+		* @param getArgs - A function that returns the arguments for the call.
+		* @param deferred - A flag indicating whether the call should be deferred.
+		* @param debounce - The debounce time in milliseconds.
+		* @returns {IRPCReader<IRPCData>} - The reader for the call.
+		*/
+		function prepare(getArgs, deferred, debounce = 0) {
+			const reader = new IRPCReader(uuid(), spec.init(), deferred ? IRPC_STATUS.IDLE : IRPC_STATUS.PENDING);
+			if (isBrowser()) {
+				const observer = createObserver(() => {
+					observer.reset();
+					dispatch();
+				});
+				const [schedule, cancel] = microtask(debounce);
+				const dispatch = (coalesce = true) => {
+					const args = observer.run(getArgs);
+					if (!coalesce) return execute(args, reader);
+					schedule(() => {
+						execute(args, reader);
+					});
+				};
+				if (deferred) observer.run(getArgs);
+				else dispatch(false);
+				onCleanup(() => {
+					cancel();
+					observer.destroy();
+				});
+			}
+			return reader;
+		}
+		const execute = (args, reader) => {
 			if (!this.transport && typeof spec.handler !== "function") return Promise.reject(new Error(ERROR_MESSAGE[ERROR_CODE.TRANSPORT_MISSING]));
+			reader.status = IRPC_STATUS.PENDING;
 			const callKey = JSON.stringify(args);
 			const cached = caches.get(callKey);
 			if (cached) return cached.value;
 			if (spec.coalesce !== false && calls.has(callKey)) return calls.get(callKey);
-			const { timeout, maxRetries, retryDelay, retryMode } = {
+			const { timeout, maxRetries, retryDelay, retryMode, init } = {
 				...this.config,
 				...spec
 			};
@@ -89,19 +163,25 @@ var IRPCPackage = class {
 				timeout,
 				maxRetries,
 				retryDelay,
-				retryMode
+				retryMode,
+				init
 			};
-			const call = typeof spec.handler === "function" ? spec.handler(...args) : this.transport.call(spec, args, config);
+			const hooks = this.hooks.get(spec);
+			if (hooks) hooks.forEach((hook) => hook({
+				name: spec.name,
+				args
+			}));
+			const call = typeof spec.handler === "function" ? intercept(spec, args, reader) : this.transport.call(spec, args, config, reader);
 			calls.set(callKey, call);
 			if (spec.maxAge) caches.set(callKey, call, spec.maxAge);
-			if (typeof spec.init === "function" && call instanceof RemoteState && typeof call.data === "undefined") call.data = spec.init();
-			if (call instanceof Promise) call.finally(() => calls.delete(callKey)).catch(() => {});
-			else calls.delete(callKey);
-			return call;
-		});
-		this.specs.set(options.name, spec);
+			onCleanup(() => call.close());
+			call.finally(() => calls.delete(callKey)).catch((err) => IRPC_STORE.error(err, [{ name: spec.name }]));
+			return reader;
+		};
+		this.specs.set($options.name, spec);
 		this.stubs.set(stub, spec);
 		this.cache.set(stub, caches);
+		this.hooks.set(spec, /* @__PURE__ */ new Set());
 		return stub;
 	}
 	/**
@@ -132,6 +212,35 @@ var IRPCPackage = class {
 		return this;
 	}
 	/**
+	* Registers a hook function for a specific stub function
+	* @param stub - The stub function created by declare()
+	* @param handler - The hook function to register
+	* @returns This IRPCPackage instance for chaining
+	* @throws Error if the stub is invalid or if no IRPC exists for the stub
+	*/
+	hook(stub, handler) {
+		if (!this.stubs.has(stub)) {
+			const error = new Error(ERROR_MESSAGE[ERROR_CODE.NOT_FOUND]);
+			IRPC_STORE.error(error);
+			return this;
+		}
+		const spec = this.stubs.get(stub);
+		this.hooks.get(spec).add(handler);
+		return this;
+	}
+	/**
+	* Resolves and executes all registered hooks for a given request
+	* @param req - The request containing the IRPC name and arguments
+	* @returns A promise that resolves when all hooks have been executed
+	* @throws Error if no IRPC exists for the request or if the hooks are not registered
+	*/
+	async resolveHooks(req) {
+		const spec = this.specs.get(req.name);
+		if (!spec || !this.hooks.has(spec)) throw new Error(ERROR_MESSAGE[ERROR_CODE.NOT_FOUND]);
+		const hooks = this.hooks.get(spec);
+		for (const hook of hooks) await hook(req);
+	}
+	/**
 	* Sets the transport mechanism for this package
 	* @param transport - The transport instance to use for remote calls
 	* @returns This IRPCPackage instance for chaining
@@ -139,6 +248,8 @@ var IRPCPackage = class {
 	*/
 	use(transport) {
 		if (!(transport instanceof IRPCTransport)) throw new Error(ERROR_MESSAGE[ERROR_CODE.TRANSPORT_INVALID]);
+		if (this.transport) this.transport.modules.delete(this);
+		transport.modules.add(this);
 		this.config.transport = transport;
 		return this;
 	}
@@ -183,6 +294,66 @@ var IRPCPackage = class {
 function createPackage(config) {
 	return new IRPCPackage(config);
 }
+/**
+* Intercepts local function call to get an instant response without remote execution.
+*
+* @param reader - The reader object to intercept.
+* @param spec - The IRPC specification for the function call.
+* @param args - The arguments to be passed to the function.
+* @returns {IRPCReader<IRPCData>} - The IRPCReader object for consumer.
+*/
+function intercept(spec, args, reader) {
+	const signal = getAbortSignal();
+	if (signal?.aborted) {
+		reader.abort();
+		return reader;
+	}
+	const abort = () => reader.abort();
+	signal?.addEventListener("abort", abort, { once: true });
+	try {
+		const result = spec.handler(...args);
+		if (!(result instanceof Promise)) {
+			reader.accept(result);
+			signal?.removeEventListener("abort", abort);
+			return reader;
+		}
+		if (!(result instanceof RemoteState)) {
+			result.then((value) => {
+				reader.accept(value);
+			}).catch((err) => {
+				reader.reject(err);
+			}).finally(() => {
+				signal?.removeEventListener("abort", abort);
+			});
+			return reader;
+		}
+		anchor.assign(reader.state, result.state);
+		const unsubscribe = result.subscribe((_, event) => {
+			if (event.type === "init") return;
+			const [rootKey] = event.keys;
+			if (rootKey === "status") {
+				reader.status = event.value;
+				if (reader.status === IRPC_STATUS.SUCCESS || reader.status === IRPC_STATUS.ERROR) {
+					signal?.removeEventListener("abort", subAbort);
+					unsubscribe();
+				}
+				return;
+			}
+			replay(reader.state, event);
+		});
+		const subAbort = () => {
+			unsubscribe();
+			reader.abort();
+			result.abort();
+		};
+		signal?.addEventListener("abort", subAbort, { once: true });
+		signal?.removeEventListener("abort", abort);
+	} catch (error) {
+		reader.reject(error);
+		signal?.removeEventListener("abort", abort);
+	}
+	return reader;
+}
 
 //#endregion
-export { IRPCPackage, createPackage };
+export { IRPCPackage, createPackage, intercept };

package/dist/packet.d.ts

@@ -0,0 +1,32 @@
+import { IRPCFileMeta, IRPCFileStream } from "./file.js";
+import { IRPCData } from "./types.js";
+
+//#region src/packet.d.ts
+declare const IRPC_FILE_IDENTIFIER: "IRPC_PACKET_FILE";
+type IRPCFilePointer = {
+  id: string;
+  type: typeof IRPC_FILE_IDENTIFIER;
+  meta: IRPCFileMeta;
+};
+type IRPCFileQueue = {
+  file: IRPCFilePointer;
+  data: Blob;
+};
+type IRPCPacketJson = {
+  data: IRPCData;
+  files: IRPCFilePointer[];
+};
+type IRPCPacketQueues = {
+  json: IRPCPacketJson;
+  queues: IRPCFileQueue[];
+};
+type PacketStream = {
+  data: IRPCData;
+  files: Map<string, IRPCFileStream>;
+  resolved: number;
+};
+declare function isFilePointer(data: IRPCData): boolean;
+declare function encode(data: IRPCData): IRPCPacketQueues;
+declare function decode(packet: IRPCPacketJson): PacketStream;
+//#endregion
+export { IRPCFilePointer, IRPCFileQueue, IRPCPacketJson, IRPCPacketQueues, IRPC_FILE_IDENTIFIER, PacketStream, decode, encode, isFilePointer };

package/dist/packet.js

@@ -0,0 +1,100 @@
+import { IRPCFile, IRPCFileStream } from "./file.js";
+import { isArray, isObject, uuid } from "@anchorlib/core";
+
+//#region src/packet.ts
+const IRPC_FILE_IDENTIFIER = "IRPC_PACKET_FILE";
+function isFilePointer(data) {
+	return isObject(data) && data.type === IRPC_FILE_IDENTIFIER;
+}
+function encode(data) {
+	const json = {
+		data,
+		files: []
+	};
+	const packet = {
+		json,
+		queues: []
+	};
+	if (data instanceof IRPCFile) {
+		const { pointer, queue } = createPointer(data);
+		json.data = pointer;
+		json.files.push(pointer);
+		packet.queues.push(queue);
+	} else if (isObject(data) || isArray(data)) encodePointers(data, json.files, packet.queues);
+	return packet;
+}
+function decode(packet) {
+	const files = packet.files.map((file) => {
+		return [file.id, new IRPCFileStream(file.meta)];
+	});
+	const stream = {
+		data: packet.data,
+		files: new Map(files),
+		resolved: 0
+	};
+	if (isFilePointer(packet.data)) {
+		const { id } = packet.data;
+		stream.data = stream.files.get(id);
+	} else if (isObject(packet.data) || isArray(packet.data)) decodePointers(packet.data, stream.files);
+	return stream;
+}
+function createPointer(file) {
+	const pointer = {
+		id: uuid(),
+		meta: file.meta,
+		type: IRPC_FILE_IDENTIFIER
+	};
+	return {
+		pointer,
+		queue: {
+			file: pointer,
+			data: file.data
+		}
+	};
+}
+/**
+* Replace all IRPCFile inside an object with IRPCPacketFile.
+* @param {Record<string, unknown> | unknown[]} data - The object to encode.
+* @param {IRPCFilePointer[]} pointers - The array of IRPCPacketFile to replace.
+* @param {IRPCFileQueue[]} queues - The array of IRPCPacketFileQueue to replace.
+*/
+function encodePointers(data, pointers, queues) {
+	if (isArray(data)) data.forEach((item, i) => {
+		if (item instanceof IRPCFile) {
+			const { pointer, queue } = createPointer(item);
+			data[i] = pointer;
+			pointers.push(pointer);
+			queues.push(queue);
+		} else if (isObject(item) || isArray(item)) encodePointers(item, pointers, queues);
+	});
+	else if (isObject(data)) Object.entries(data).forEach(([key, value]) => {
+		if (value instanceof IRPCFile) {
+			const { pointer, queue } = createPointer(value);
+			data[key] = pointer;
+			pointers.push(pointer);
+			queues.push(queue);
+		} else if (isObject(value) || isArray(value)) encodePointers(value, pointers, queues);
+	});
+}
+/**
+* Replace all IRPCPacketFile inside an object with IRPCFileStream.
+* @param data - The object to decode.
+* @param files - The map of IRPCFileStream to replace.
+*/
+function decodePointers(data, files) {
+	if (isArray(data)) data.forEach((item, i) => {
+		if (isFilePointer(item)) {
+			const { id } = item;
+			data[i] = files.get(id);
+		} else if (isObject(item) || isArray(item)) decodePointers(item, files);
+	});
+	else if (isObject(data)) Object.entries(data).forEach(([key, value]) => {
+		if (isFilePointer(value)) {
+			const { id } = value;
+			data[key] = files.get(id);
+		} else if (isObject(value) || isArray(value)) decodePointers(value, files);
+	});
+}
+
+//#endregion
+export { IRPC_FILE_IDENTIFIER, decode, encode, isFilePointer };

package/dist/reader.d.ts

@@ -1,4 +1,4 @@
-import { IRPCData, IRPCPacketStream } from "./types.js";
+import { IRPCData, IRPCPacketStream, IRPCStatus } from "./types.js";
 import { RemoteState } from "./state.js";
 
 //#region src/reader.d.ts
@@ -10,8 +10,16 @@ import { RemoteState } from "./state.js";
  */
 declare class IRPCReader<T extends IRPCData> extends RemoteState<T> {
   id: string;
-  packets: Set<IRPCPacketStream<T>>;
-  constructor(id: string, init?: T);
+  onClose?: () => void;
+  /**
+   * Initializes a new RemoteState with an optional initial payload.
+   *
+   * @param id - The unique identifier for this state instance.
+   * @param init - An optional starting value for the data payload.
+   * @param status - The initial status of the state (PENDING, SUCCESS, ERROR).
+   * @param resumable - Whether the state should be resumable after being closed.
+   */
+  constructor(id: string, init?: T, status?: IRPCStatus, resumable?: boolean);
   /**
    * Pushes incoming network packets into this reader, evaluating payload data
    * and subsequently updating the core state values locally.
@@ -19,6 +27,12 @@ declare class IRPCReader<T extends IRPCData> extends RemoteState<T> {
    * @param packet - The incoming unified Stream Packet structure (`ANSWER`, `EVENT`, or `CLOSE`).
    */
   push(packet: IRPCPacketStream<T>): void;
+  close(): void;
+  /**
+   * Ensures that chained Promise operations return standard Promises
+   * rather than instantiating new RemoteState subclasses.
+   */
+  static get [Symbol.species](): PromiseConstructor;
 }
 //#endregion
 export { IRPCReader };

package/dist/reader.js

@@ -9,9 +9,17 @@ import { replay } from "@anchorlib/core";
 * @template T - The type of data yielded by the stream.
 */
 var IRPCReader = class extends RemoteState {
-	packets = /* @__PURE__ */ new Set();
-	constructor(id, init) {
-		super(init);
+	onClose;
+	/**
+	* Initializes a new RemoteState with an optional initial payload.
+	*
+	* @param id - The unique identifier for this state instance.
+	* @param init - An optional starting value for the data payload.
+	* @param status - The initial status of the state (PENDING, SUCCESS, ERROR).
+	* @param resumable - Whether the state should be resumable after being closed.
+	*/
+	constructor(id, init, status = IRPC_STATUS.PENDING, resumable) {
+		super(init, status, resumable);
 		this.id = id;
 	}
 	/**
@@ -22,7 +30,6 @@ var IRPCReader = class extends RemoteState {
 	*/
 	push(packet) {
 		packet.arrivedAt = Date.now();
-		this.packets.add(packet);
 		if (packet.type === IRPC_PACKET_TYPE.ANSWER) if (packet.status === IRPC_STATUS.ERROR) this.error = new Error(packet.error.message);
 		else this.data = packet.data;
 		else if (packet.type === IRPC_PACKET_TYPE.EVENT) replay(this.state, packet.data);
@@ -31,6 +38,18 @@ var IRPCReader = class extends RemoteState {
 		}
 		this.status = packet.status;
 	}
+	close() {
+		this.status = IRPC_STATUS.SUCCESS;
+		super.close();
+		this.onClose?.();
+	}
+	/**
+	* Ensures that chained Promise operations return standard Promises
+	* rather than instantiating new RemoteState subclasses.
+	*/
+	static get [Symbol.species]() {
+		return Promise;
+	}
 };
 
 //#endregion

package/dist/resolver.d.ts

@@ -1,5 +1,5 @@
-import { IRPCDataSchema, IRPCInputs, IRPCOutput, IRPCRequest, IRPCResponse, IRPCSpec } from "./types.js";
 import { IRPCPackage } from "./module.js";
+import { IRPCDataSchema, IRPCInputs, IRPCOutput, IRPCRequest, IRPCResponse, IRPCSpec } from "./types.js";
 
 //#region src/resolver.d.ts
 

package/dist/resolver.js

@@ -70,6 +70,11 @@ var IRPCResolver = class {
 	*/
 	async forward({ id, name, args }, schema) {
 		try {
+			await this.module.resolveHooks({
+				id,
+				name,
+				args
+			});
 			const result = this.module.resolve({
 				id,
 				name,
@@ -91,7 +96,25 @@ var IRPCResolver = class {
 					result
 				};
 			}
-			const output = parseOutput(await result, schema);
+			const data = await result;
+			if (data instanceof RemoteState) {
+				data.unpipe();
+				const output$1 = parseOutput(data.data, schema);
+				if (!output$1.success) return {
+					id,
+					name,
+					error: {
+						code: ERROR_CODE.INVALID_OUTPUT,
+						message: output$1.error?.message
+					}
+				};
+				return {
+					id,
+					name,
+					result: data
+				};
+			}
+			const output = parseOutput(data, schema);
 			if (output.success) return {
 				id,
 				name,
@@ -110,7 +133,7 @@ var IRPCResolver = class {
 				id,
 				name,
 				error: {
-					code: ERROR_CODE.UNKNOWN,
+					code: ERROR_CODE.HANDLER_ERROR,
 					message: error.message
 				}
 			};

package/dist/router.d.ts

@@ -0,0 +1,53 @@
+import { IRPCPackage } from "./module.js";
+import { IRPCTransport } from "./transport.js";
+import { IRPCRequest } from "./types.js";
+
+//#region src/router.d.ts
+type IRPCHook = () => void | Promise<void>;
+declare class IRPCRouter {
+  module: IRPCPackage;
+  transport: IRPCTransport;
+  /** Array of middleware functions to be executed */
+  hooks: IRPCHook[];
+  /**
+   * Creates a new Router instance
+   * @param {IRPCPackage} module - The IRPC package module to resolve requests against
+   * @param {IRPCTransport} transport - The transport mechanism to use for resolving requests
+   */
+  constructor(module: IRPCPackage, transport: IRPCTransport);
+  /**
+   * Adds a hook function to the router
+   * @param hook - The hook function to add
+   * @returns The current Router instance for chaining
+   */
+  use(hook: IRPCHook): this;
+  /**
+   * Run a function within an isolated IRPC Router context.
+   * This make sure any subsequent RPC calls will be seeded with the hooks added to the router.
+   *
+   * @param handler - The handler function to isolate
+   * @param controller - The AbortController to use for cancellation
+   * @param context - Additional context to pass to the handler
+   * @param preHook - A hook function to run before the router hooks
+   * @returns The result of the isolated handler function
+   */
+  isolate<T>(handler: () => T | Promise<T>, controller: AbortController, context?: Array<[string | symbol, unknown]>, preHook?: IRPCHook): Promise<Promise<T>>;
+  /**
+   * Resolves hook functions for a given request
+   * @param req - The IRPC request to process hook for
+   * @returns An error response if hook fails, undefined otherwise
+   */
+  protected resolveHooks(req: IRPCRequest): Promise<{
+    id: string;
+    name: string;
+    type: "close";
+    status: "error";
+    error: {
+      code: string;
+      message: string;
+    };
+    createdAt: number;
+  } | undefined>;
+}
+//#endregion
+export { IRPCHook, IRPCRouter };