@irpclib/irpc 1.0.0-beta.21 → 1.0.0-beta.23

package/dist/call.d.ts

@@ -16,7 +16,7 @@ declare class IRPCCall {
   /**
    * Unique identifier for this RPC call, generated using shortId().
    */
-  id: string;
+  readonly id: string;
   /**
    * The status of the RPC call, indicating whether it is pending, resolved, or rejected.
    */
@@ -39,17 +39,19 @@ declare class IRPCCall {
    */
   value?: unknown;
   error?: Error;
-  private readonly timerId?;
+  private timerId?;
+  private retryId?;
   private retries;
   private retryReasons;
   reader: IRPCReader<IRPCData>;
   /**
    * Creates a new IRPCCall instance.
-   * @param transport
+   * @param reader - The reader associated with this call.
+   * @param transport - The transport used for dispatching calls.
    * @param payload - The RPC payload containing method and parameters
    * @param options - Options for the call, such as timeout, maxRetries, etc.
    */
-  constructor(transport: IRPCTransport, payload: IRPCPayload, options: IRPCCallConfig);
+  constructor(transport: IRPCTransport, payload: IRPCPayload, options: IRPCCallConfig, reader?: IRPCReader<IRPCData>);
   enqueue(packet: IRPCPacketStream<IRPCData>): void;
   /**
    * Resolves the RPC call with the provided value.
@@ -64,6 +66,7 @@ declare class IRPCCall {
    * @param retriable - Flag indicating whether to retry the call
    */
   reject(reason?: Error, retriable?: boolean): void;
+  close(): void;
 }
 //#endregion
 export { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, IRPCCall };

package/dist/call.js

@@ -1,7 +1,8 @@
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
 import { IRPCReader } from "./reader.js";
-import { uuid } from "./uuid.js";
+import { IRPC_STORE } from "./store.js";
+import { uuid } from "@anchorlib/core";
 
 //#region src/call.ts
 const DEFAULT_RETRY_MODE = "exponential";
@@ -14,7 +15,7 @@ var IRPCCall = class {
 	/**
 	* Unique identifier for this RPC call, generated using shortId().
 	*/
-	id = uuid();
+	id;
 	/**
 	* The status of the RPC call, indicating whether it is pending, resolved, or rejected.
 	*/
@@ -38,16 +39,18 @@ var IRPCCall = class {
 	value;
 	error;
 	timerId;
+	retryId;
 	retries = 0;
 	retryReasons = /* @__PURE__ */ new Set();
 	reader;
 	/**
 	* Creates a new IRPCCall instance.
-	* @param transport
+	* @param reader - The reader associated with this call.
+	* @param transport - The transport used for dispatching calls.
 	* @param payload - The RPC payload containing method and parameters
 	* @param options - Options for the call, such as timeout, maxRetries, etc.
 	*/
-	constructor(transport, payload, options) {
+	constructor(transport, payload, options, reader) {
 		this.transport = transport;
 		this.payload = payload;
 		this.options = options;
@@ -63,11 +66,15 @@ var IRPCCall = class {
 				},
 				createdAt: Date.now()
 			});
+			clearTimeout(this.retryId);
 			this.reject(new Error(ERROR_MESSAGE[ERROR_CODE.TIMEOUT]), false);
 		}, options.timeout);
-		this.reader = new IRPCReader(this.id);
+		this.reader = reader ?? new IRPCReader(uuid(), options?.init?.());
+		this.reader.onClose = () => this.close();
+		this.id = this.reader.id;
 	}
 	enqueue(packet) {
+		if (this.resolved) return;
 		this.reader.push(packet);
 		if (this.reader.status === IRPC_STATUS.SUCCESS) this.resolve(this.reader.data);
 		else if (this.reader.status === IRPC_STATUS.ERROR) this.reject(this.reader.error);
@@ -83,6 +90,7 @@ var IRPCCall = class {
 		this.status = IRPC_STATUS.SUCCESS;
 		this.resolved = true;
 		this.finishedAt = Date.now();
+		this.retryReasons.clear();
 		clearTimeout(this.timerId);
 	}
 	/**
@@ -97,12 +105,16 @@ var IRPCCall = class {
 		if (maxRetries && retriable) {
 			if (reason) this.retryReasons.add(reason);
 			if (this.retries >= maxRetries) {
-				console.error(ERROR_MESSAGE[ERROR_CODE.CALL_MAX_RETRIES_REACHED], this.retryReasons);
+				IRPC_STORE.error(/* @__PURE__ */ new Error(`${ERROR_MESSAGE[ERROR_CODE.CALL_MAX_RETRIES_REACHED]}: ${Array.from(this.retryReasons).map((r) => r.message).join(", ")}`), [{
+					id: this.id,
+					name: this.payload.name
+				}]);
 				this.reject(reason, false);
+				this.retryReasons.clear();
 				return;
 			}
 			const delay = retryMode === "linear" ? retryDelay : retryDelay * 2 ** this.retries;
-			setTimeout(() => {
+			this.retryId = setTimeout(() => {
 				this.retries++;
 				this.transport.schedule(this);
 			}, delay);
@@ -111,9 +123,15 @@ var IRPCCall = class {
 			this.status = IRPC_STATUS.ERROR;
 			this.resolved = true;
 			this.finishedAt = Date.now();
+			this.retryReasons.clear();
 			clearTimeout(this.timerId);
 		}
 	}
+	close() {
+		if (this.resolved) return;
+		this.transport.close(this);
+		this.resolve(this.reader.data);
+	}
 };
 
 //#endregion

package/dist/context.d.ts

@@ -1,4 +1,5 @@
 import { IRPCContext, IRPCContextProvider } from "./types.js";
+import { AsyncStore, getContext, setContext } from "@anchorlib/core";
 
 //#region src/context.d.ts
 
@@ -16,25 +17,14 @@ declare function setContextProvider(store: IRPCContextProvider): void;
  * @param fn - The function to execute
  * @returns The result of the executed function
  */
-declare function withContext<R>(ctx: IRPCContext<string, unknown>, fn: () => R): R;
+declare function withContext<R>(ctx: IRPCContext<string | symbol, unknown>, fn: () => R): Promise<R>;
 /**
  * Creates a new context map with optional initial values.
  * @param init - Optional initial key-value pairs for the context
  * @returns A new Map instance representing the context
  */
-declare function createContext<K extends string, V>(init?: [K, V][]): Map<K, V>;
-/**
- * Sets a value in the current context.
- * @param key - The key to set in the context
- * @param value - The value to associate with the key
- */
-declare function setContext<V, K extends string = string>(key: K, value: V): void;
-/**
- * Gets a value from the current context.
- * @param key - The key to retrieve from the context
- * @param fallback - Optional fallback value if the key is not found
- * @returns The value associated with the key, or the fallback value if not found
- */
-declare function getContext<V, K extends string = string>(key: K, fallback?: V): V | undefined;
+declare function createContext<K extends string | symbol, V>(init?: [K, V][]): AsyncStore;
+declare function getAbortSignal(): AbortSignal | undefined;
+declare function getAbortController(): AbortController | undefined;
 //#endregion
-export { createContext, getContext, setContext, setContextProvider, withContext };
+export { createContext, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext };

package/dist/context.js

@@ -1,12 +1,14 @@
+import { IRPC_BASE_CONTEXT } from "./enum.js";
+import { AsyncStore, getContext, setAsyncScope, setContext, withIsolation } from "@anchorlib/core";
+
 //#region src/context.ts
-let currentStore;
 /**
 * Sets the global context store for the IRPC system.
 * This store is used to manage context data across requests.
 * @param store - The context store implementation to use
 */
 function setContextProvider(store) {
-	currentStore = store;
+	setAsyncScope(store);
 }
 /**
 * Executes a function with the provided context.
@@ -17,7 +19,7 @@ function setContextProvider(store) {
 * @returns The result of the executed function
 */
 function withContext(ctx, fn) {
-	return currentStore?.run(ctx, fn) ?? fn();
+	return withIsolation(fn, true, ctx);
 }
 /**
 * Creates a new context map with optional initial values.
@@ -25,27 +27,14 @@ function withContext(ctx, fn) {
 * @returns A new Map instance representing the context
 */
 function createContext(init) {
-	return new Map(init);
+	return new AsyncStore(init);
 }
-/**
-* Sets a value in the current context.
-* @param key - The key to set in the context
-* @param value - The value to associate with the key
-*/
-function setContext(key, value) {
-	(currentStore?.getStore())?.set(key, value);
+function getAbortSignal() {
+	return getContext(IRPC_BASE_CONTEXT.ABORT_SIGNAL);
 }
-/**
-* Gets a value from the current context.
-* @param key - The key to retrieve from the context
-* @param fallback - Optional fallback value if the key is not found
-* @returns The value associated with the key, or the fallback value if not found
-*/
-function getContext(key, fallback) {
-	const result = (currentStore?.getStore())?.get(key);
-	if (typeof result === "undefined" && typeof fallback !== "undefined") return fallback;
-	return result;
+function getAbortController() {
+	return getContext(IRPC_BASE_CONTEXT.ABORT_CONTROLLER);
 }
 
 //#endregion
-export { createContext, getContext, setContext, setContextProvider, withContext };
+export { createContext, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext };

package/dist/enum.d.ts

@@ -14,22 +14,29 @@ declare const IRPC_DATA_TYPE: {
   readonly WRITABLE: "writable";
   readonly PRIMITIVE: "primitive";
 };
-declare const IRPC_EVENT_TYPE: {
-  readonly OBJECT_SET: "set";
-  readonly OBJECT_DELETE: "delete";
-  readonly ARRAY_PUSH: "push";
-  readonly ARRAY_POP: "pop";
-  readonly ARRAY_SHIFT: "shift";
-  readonly ARRAY_UNSHIFT: "unshift";
-  readonly ARRAY_SPLICE: "splice";
-  readonly ARRAY_REVERSE: "reverse";
-  readonly ARRAY_COPY_WITHIN: "copyWithin";
-};
 declare const IRPC_STATUS: {
   readonly IDLE: "idle";
   readonly ERROR: "error";
   readonly PENDING: "pending";
   readonly SUCCESS: "success";
+  readonly ABORTED: "aborted";
+};
+declare const IRPC_STORE_EVENT: {
+  readonly ROUTE: "route";
+  readonly QUEUE: "queue";
+  readonly DEQUEUE: "dequeue";
+  readonly REGISTER: "register";
+  readonly ERROR: "error";
+};
+declare const IRPC_BASE_CONTEXT: {
+  readonly ABORT_SIGNAL: symbol;
+  readonly ABORT_CONTROLLER: symbol;
+};
+declare const IRPC_FILE_STATUS: {
+  readonly IDLE: "idle";
+  readonly PENDING: "pending";
+  readonly SUCCESS: "success";
+  readonly ERROR: "error";
 };
 //#endregion
-export { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS };
+export { IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE_EVENT };

package/dist/enum.js

@@ -14,23 +14,30 @@ const IRPC_DATA_TYPE = {
 	WRITABLE: "writable",
 	PRIMITIVE: "primitive"
 };
-const IRPC_EVENT_TYPE = {
-	OBJECT_SET: "set",
-	OBJECT_DELETE: "delete",
-	ARRAY_PUSH: "push",
-	ARRAY_POP: "pop",
-	ARRAY_SHIFT: "shift",
-	ARRAY_UNSHIFT: "unshift",
-	ARRAY_SPLICE: "splice",
-	ARRAY_REVERSE: "reverse",
-	ARRAY_COPY_WITHIN: "copyWithin"
-};
 const IRPC_STATUS = {
 	IDLE: "idle",
 	ERROR: "error",
 	PENDING: "pending",
-	SUCCESS: "success"
+	SUCCESS: "success",
+	ABORTED: "aborted"
+};
+const IRPC_STORE_EVENT = {
+	ROUTE: "route",
+	QUEUE: "queue",
+	DEQUEUE: "dequeue",
+	REGISTER: "register",
+	ERROR: "error"
+};
+const IRPC_BASE_CONTEXT = {
+	ABORT_SIGNAL: Symbol("abort-signal"),
+	ABORT_CONTROLLER: Symbol("abort-controller")
+};
+const IRPC_FILE_STATUS = {
+	IDLE: "idle",
+	PENDING: "pending",
+	SUCCESS: "success",
+	ERROR: "error"
 };
 
 //#endregion
-export { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS };
+export { IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE_EVENT };

package/dist/error.d.ts

@@ -12,6 +12,7 @@ declare const ERROR_CODE: {
   NOT_IMPLEMENTED: string;
   INVALID_HANDLER: string;
   INVALID_OPERATION: string;
+  INVALID_HOOK: string;
   TRANSPORT_MISSING: string;
   TRANSPORT_INVALID: string;
   TRANSPORT_NOT_IMPLEMENTED: string;
@@ -39,6 +40,7 @@ declare const ERROR_MESSAGE: {
   [ERROR_CODE.NOT_IMPLEMENTED]: string;
   [ERROR_CODE.INVALID_HANDLER]: string;
   [ERROR_CODE.INVALID_OPERATION]: string;
+  [ERROR_CODE.INVALID_HOOK]: string;
   [ERROR_CODE.TRANSPORT_MISSING]: string;
   [ERROR_CODE.TRANSPORT_INVALID]: string;
   [ERROR_CODE.TRANSPORT_NOT_IMPLEMENTED]: string;

package/dist/error.js

@@ -12,6 +12,7 @@ const ERROR_CODE = {
 	NOT_IMPLEMENTED: "not_implemented",
 	INVALID_HANDLER: "invalid_handler",
 	INVALID_OPERATION: "invalid_operation",
+	INVALID_HOOK: "invalid_middleware",
 	TRANSPORT_MISSING: "transport_missing",
 	TRANSPORT_INVALID: "transport_invalid",
 	TRANSPORT_NOT_IMPLEMENTED: "transport_not_implemented",
@@ -38,6 +39,7 @@ const ERROR_MESSAGE = {
 	[ERROR_CODE.NOT_IMPLEMENTED]: "IRPC: Not implemented error",
 	[ERROR_CODE.INVALID_HANDLER]: "IRPC: Invalid handler error",
 	[ERROR_CODE.INVALID_OPERATION]: "IRPC: Invalid operation error",
+	[ERROR_CODE.INVALID_HOOK]: "IRPC: Invalid hook error",
 	[ERROR_CODE.TRANSPORT_MISSING]: "IRPC: Transport missing error",
 	[ERROR_CODE.TRANSPORT_INVALID]: "IRPC: Transport invalid error",
 	[ERROR_CODE.TRANSPORT_NOT_IMPLEMENTED]: "IRPC: Transport not implemented error",

package/dist/file.d.ts

@@ -0,0 +1,37 @@
+import { IRPC_FILE_STATUS } from "./enum.js";
+
+//#region src/file.d.ts
+type IRPCFileStatus = (typeof IRPC_FILE_STATUS)[keyof typeof IRPC_FILE_STATUS];
+type IRPCFileState = {
+  error?: Error;
+  status: IRPCFileStatus;
+  downloaded: number;
+};
+type IRPCFileMeta = {
+  size: number;
+  type: string;
+  name?: string;
+};
+type IRPCFilePipe = (chunk: Uint8Array) => void;
+type IRPCFileUnpipe = () => void;
+declare class IRPCFile {
+  meta: IRPCFileMeta;
+  protected state: IRPCFileState;
+  get status(): IRPCFileStatus;
+  set status(status: IRPCFileStatus);
+  get error(): Error | undefined;
+  get downloaded(): number;
+  get success(): boolean;
+  get completed(): boolean;
+  data: Blob;
+  constructor(meta: IRPCFileMeta, data?: Blob);
+}
+declare class IRPCFileStream extends IRPCFile {
+  private pipes;
+  private buffer;
+  constructor(meta: IRPCFileMeta);
+  write(chunk: Uint8Array): Uint8Array<ArrayBuffer> | null;
+  pipe(fn: IRPCFilePipe): IRPCFileUnpipe;
+}
+//#endregion
+export { IRPCFile, IRPCFileMeta, IRPCFilePipe, IRPCFileState, IRPCFileStatus, IRPCFileStream, IRPCFileUnpipe };

package/dist/file.js

@@ -0,0 +1,86 @@
+import { IRPC_FILE_STATUS } from "./enum.js";
+import { IRPC_STORE } from "./store.js";
+import { mutable } from "@anchorlib/core";
+
+//#region src/file.ts
+var IRPCFile = class {
+	state = mutable({
+		status: IRPC_FILE_STATUS.PENDING,
+		downloaded: 0
+	});
+	get status() {
+		return this.state.status;
+	}
+	set status(status) {
+		this.state.status = status;
+	}
+	get error() {
+		return this.state.error;
+	}
+	get downloaded() {
+		return this.state.downloaded;
+	}
+	get success() {
+		return this.status === IRPC_FILE_STATUS.SUCCESS;
+	}
+	get completed() {
+		return [IRPC_FILE_STATUS.SUCCESS, IRPC_FILE_STATUS.ERROR].includes(this.status);
+	}
+	data;
+	constructor(meta, data) {
+		this.meta = meta;
+		this.data = data ?? new Blob([], { type: meta.type });
+		this.state.status = data ? IRPC_FILE_STATUS.SUCCESS : IRPC_FILE_STATUS.PENDING;
+	}
+};
+var IRPCFileStream = class extends IRPCFile {
+	pipes = /* @__PURE__ */ new Set();
+	buffer;
+	constructor(meta) {
+		super(meta);
+		this.data = new Blob([], { type: meta.type });
+		this.buffer = new Uint8Array(meta.size);
+	}
+	write(chunk) {
+		if (this.completed) return null;
+		try {
+			const remaining = this.meta.size - this.state.downloaded;
+			const chunkSize = Math.min(chunk.byteLength, remaining);
+			const needSlice = chunkSize < chunk.byteLength;
+			const nextChunk = needSlice ? chunk.slice(0, chunkSize) : chunk;
+			const leftovers = needSlice ? chunk.slice(chunkSize) : null;
+			this.buffer?.set(nextChunk, this.state.downloaded);
+			this.state.downloaded += chunkSize;
+			this.pipes.forEach((fn) => {
+				try {
+					fn(nextChunk);
+				} catch (error) {
+					IRPC_STORE.error(error, [this.meta]);
+				}
+			});
+			if (this.downloaded >= this.meta.size) {
+				this.data = new Blob([this.buffer], { type: this.meta.type });
+				this.buffer = void 0;
+				this.state.status = IRPC_FILE_STATUS.SUCCESS;
+			}
+			return leftovers;
+		} catch (error) {
+			IRPC_STORE.error(error, [this.meta]);
+			this.state.error = error;
+			this.state.status = IRPC_FILE_STATUS.ERROR;
+		}
+		return null;
+	}
+	pipe(fn) {
+		this.pipes.add(fn);
+		if (this.state.downloaded > 0) try {
+			fn(this.buffer?.subarray(0, this.state.downloaded));
+		} catch (error) {
+			IRPC_STORE.error(error, [this.meta]);
+		}
+		return () => this.pipes.delete(fn);
+	}
+};
+
+//#endregion
+export { IRPCFile, IRPCFileStream };

package/dist/index.d.ts

@@ -1,13 +1,18 @@
 import { IRPCCacheEntry, IRPCCacher } from "./cache.js";
-import { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
+import { IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE_EVENT } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE, ErrorCode } from "./error.js";
+import { IRPCFile, IRPCFileMeta, IRPCFilePipe, IRPCFileState, IRPCFileStatus, IRPCFileStream, IRPCFileUnpipe } from "./file.js";
 import { IRPCTransport } from "./transport.js";
-import { IRPCArraySchema, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCDataType, IRPCDeclareInit, IRPCError, IRPCEventType, IRPCHandler, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketData, IRPCPacketEvent, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStubStore, TransportConfig } from "./types.js";
-import { RemoteState, StreamConstructor, stream } from "./state.js";
+import { IRPCArraySchema, IRPCBaseContext, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCDataType, IRPCDeclareInit, IRPCError, IRPCFunction, IRPCHandler, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketEvent, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStreamInit, IRPCStub, IRPCStubStore, StreamCleanup, StreamConstructor, TransportConfig } from "./types.js";
+import { RemoteState, stream } from "./state.js";
 import { IRPCReader } from "./reader.js";
 import { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, IRPCCall } from "./call.js";
-import { createContext, getContext, setContext, setContextProvider, withContext } from "./context.js";
-import { IRPCPackage, createPackage } from "./module.js";
+import { createContext, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext } from "./context.js";
+import { IRPCHookArgs, IRPCPackage, IRPCSpecHook, createPackage, intercept } from "./module.js";
+import { IRPCFilePointer, IRPCFileQueue, IRPCPacketJson, IRPCPacketQueues, IRPC_FILE_IDENTIFIER, PacketStream, decode, encode, isFilePointer } from "./packet.js";
 import { IRPCResolver } from "./resolver.js";
+import { IRPCHook, IRPCRouter } from "./router.js";
 import { IRPCStream } from "./stream.js";
-export { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, ERROR_CODE, ERROR_MESSAGE, ErrorCode, IRPCArraySchema, IRPCCacheEntry, IRPCCacher, IRPCCall, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCDataType, IRPCDeclareInit, IRPCError, IRPCEventType, IRPCHandler, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackage, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketData, IRPCPacketEvent, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCReader, IRPCRequest, IRPCResolver, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStream, IRPCStubStore, IRPCTransport, IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS, RemoteState, StreamConstructor, TransportConfig, createContext, createPackage, getContext, setContext, setContextProvider, stream, withContext };
+import { IRPCStore, IRPCStoreEvent, IRPCStoreSubscriber, IRPC_STORE } from "./store.js";
+import { plan } from "@anchorlib/core";
+export { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, ERROR_CODE, ERROR_MESSAGE, ErrorCode, IRPCArraySchema, IRPCBaseContext, IRPCCacheEntry, IRPCCacher, IRPCCall, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCDataType, IRPCDeclareInit, IRPCError, IRPCFile, IRPCFileMeta, IRPCFilePipe, IRPCFilePointer, IRPCFileQueue, IRPCFileState, IRPCFileStatus, IRPCFileStream, IRPCFileUnpipe, IRPCFunction, IRPCHandler, IRPCHook, IRPCHookArgs, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackage, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketEvent, IRPCPacketJson, IRPCPacketQueues, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCReader, IRPCRequest, IRPCResolver, IRPCResponse, IRPCRouter, IRPCSchema, IRPCSpec, IRPCSpecHook, IRPCSpecStore, IRPCStatus, IRPCStore, IRPCStoreEvent, IRPCStoreSubscriber, IRPCStream, IRPCStreamInit, IRPCStub, IRPCStubStore, IRPCTransport, IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_FILE_IDENTIFIER, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE, IRPC_STORE_EVENT, PacketStream, RemoteState, StreamCleanup, StreamConstructor, TransportConfig, createContext, createPackage, decode, encode, getAbortController, getAbortSignal, getContext, intercept, isFilePointer, plan, setContext, setContextProvider, stream, withContext };

package/dist/index.js

@@ -1,13 +1,18 @@
 import { IRPCCacher } from "./cache.js";
-import { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
+import { IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE_EVENT } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { createContext, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext } from "./context.js";
 import { RemoteState, stream } from "./state.js";
 import { IRPCReader } from "./reader.js";
-import { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, IRPCCall } from "./call.js";
-import { createContext, getContext, setContext, setContextProvider, withContext } from "./context.js";
 import { IRPCTransport } from "./transport.js";
-import { IRPCPackage, createPackage } from "./module.js";
-import { IRPCResolver } from "./resolver.js";
+import { IRPCPackage, createPackage, intercept } from "./module.js";
+import { IRPCRouter } from "./router.js";
 import { IRPCStream } from "./stream.js";
+import { IRPCStore, IRPC_STORE } from "./store.js";
+import { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, IRPCCall } from "./call.js";
+import { IRPCFile, IRPCFileStream } from "./file.js";
+import { IRPC_FILE_IDENTIFIER, decode, encode, isFilePointer } from "./packet.js";
+import { IRPCResolver } from "./resolver.js";
+import { plan } from "@anchorlib/core";
 
-export { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, ERROR_CODE, ERROR_MESSAGE, IRPCCacher, IRPCCall, IRPCPackage, IRPCReader, IRPCResolver, IRPCStream, IRPCTransport, IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS, RemoteState, createContext, createPackage, getContext, setContext, setContextProvider, stream, withContext };
+export { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, ERROR_CODE, ERROR_MESSAGE, IRPCCacher, IRPCCall, IRPCFile, IRPCFileStream, IRPCPackage, IRPCReader, IRPCResolver, IRPCRouter, IRPCStore, IRPCStream, IRPCTransport, IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_FILE_IDENTIFIER, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE, IRPC_STORE_EVENT, RemoteState, createContext, createPackage, decode, encode, getAbortController, getAbortSignal, getContext, intercept, isFilePointer, plan, setContext, setContextProvider, stream, withContext };

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 };