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

package/dist/call.d.ts

@@ -1,44 +1,69 @@
-import { IRPCPayload } from "./types.js";
+import { IRPCTransport } from "./transport.js";
+import { IRPCCallConfig, IRPCData, IRPCPacketStream, IRPCPayload, IRPCStatus } from "./types.js";
+import { IRPCReader } from "./reader.js";
 
 //#region src/call.d.ts
-
+declare const DEFAULT_RETRY_MODE = "exponential";
+declare const DEFAULT_RETRY_DELAY = 1000;
 /**
  * Represents an RPC call with promise-like behavior for handling asynchronous operations.
  * Each call has a unique identifier and manages its own resolution state.
  */
 declare class IRPCCall {
+  transport: IRPCTransport;
   payload: IRPCPayload;
-  resolver: (value: unknown) => void;
-  rejector: (reason?: Error) => void;
-  timeout?: number | undefined;
+  options: IRPCCallConfig;
   /**
    * Unique identifier for this RPC call, generated using shortId().
    */
   id: string;
+  /**
+   * The status of the RPC call, indicating whether it is pending, resolved, or rejected.
+   */
+  status: IRPCStatus;
   /**
    * Flag indicating whether this call has been resolved or rejected.
    * Prevents multiple resolutions of the same call.
    */
   resolved: boolean;
+  /**
+   * The timestamp when the RPC call was started.
+   */
+  startedAt: number;
+  /**
+   * The timestamp when the RPC call was finished.
+   */
+  finishedAt?: number;
+  /**
+   * The value returned by the RPC call.
+   */
+  value?: unknown;
+  error?: Error;
+  private readonly timerId?;
+  private retries;
+  private retryReasons;
+  reader: IRPCReader<IRPCData>;
   /**
    * Creates a new IRPCCall instance.
+   * @param transport
    * @param payload - The RPC payload containing method and parameters
-   * @param resolver - Function to resolve the associated promise with a value
-   * @param rejector - Function to reject the associated promise with an error
+   * @param options - Options for the call, such as timeout, maxRetries, etc.
    */
-  constructor(payload: IRPCPayload, resolver: (value: unknown) => void, rejector: (reason?: Error) => void, timeout?: number | undefined);
+  constructor(transport: IRPCTransport, payload: IRPCPayload, options: IRPCCallConfig);
+  enqueue(packet: IRPCPacketStream<IRPCData>): void;
   /**
    * Resolves the RPC call with the provided value.
    * If the call is already resolved, this method does nothing.
    * @param value - The value to resolve the promise with
    */
-  resolve(value: unknown): void;
+  resolve(value: IRPCData): void;
   /**
    * Rejects the RPC call with the provided reason.
    * If the call is already resolved, this method does nothing.
    * @param reason - Optional error reason for rejecting the promise
+   * @param retriable - Flag indicating whether to retry the call
    */
-  reject(reason?: Error): void;
+  reject(reason?: Error, retriable?: boolean): void;
 }
 //#endregion
-export { IRPCCall };
+export { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, IRPCCall };

package/dist/call.js

@@ -1,6 +1,11 @@
+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";
 
 //#region src/call.ts
+const DEFAULT_RETRY_MODE = "exponential";
+const DEFAULT_RETRY_DELAY = 1e3;
 /**
 * Represents an RPC call with promise-like behavior for handling asynchronous operations.
 * Each call has a unique identifier and manages its own resolution state.
@@ -11,21 +16,61 @@ var IRPCCall = class {
 	*/
 	id = uuid();
 	/**
+	* The status of the RPC call, indicating whether it is pending, resolved, or rejected.
+	*/
+	status = IRPC_STATUS.PENDING;
+	/**
 	* Flag indicating whether this call has been resolved or rejected.
 	* Prevents multiple resolutions of the same call.
 	*/
 	resolved = false;
 	/**
+	* The timestamp when the RPC call was started.
+	*/
+	startedAt = Date.now();
+	/**
+	* The timestamp when the RPC call was finished.
+	*/
+	finishedAt;
+	/**
+	* The value returned by the RPC call.
+	*/
+	value;
+	error;
+	timerId;
+	retries = 0;
+	retryReasons = /* @__PURE__ */ new Set();
+	reader;
+	/**
 	* Creates a new IRPCCall instance.
+	* @param transport
 	* @param payload - The RPC payload containing method and parameters
-	* @param resolver - Function to resolve the associated promise with a value
-	* @param rejector - Function to reject the associated promise with an error
+	* @param options - Options for the call, such as timeout, maxRetries, etc.
 	*/
-	constructor(payload, resolver, rejector, timeout) {
+	constructor(transport, payload, options) {
+		this.transport = transport;
 		this.payload = payload;
-		this.resolver = resolver;
-		this.rejector = rejector;
-		this.timeout = timeout;
+		this.options = options;
+		if (options.timeout) this.timerId = setTimeout(() => {
+			this.reader.push({
+				id: this.id,
+				name: this.payload.name,
+				type: IRPC_PACKET_TYPE.CLOSE,
+				status: IRPC_STATUS.ERROR,
+				error: {
+					code: ERROR_CODE.TIMEOUT,
+					message: ERROR_MESSAGE[ERROR_CODE.TIMEOUT]
+				},
+				createdAt: Date.now()
+			});
+			this.reject(new Error(ERROR_MESSAGE[ERROR_CODE.TIMEOUT]), false);
+		}, options.timeout);
+		this.reader = new IRPCReader(this.id);
+	}
+	enqueue(packet) {
+		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);
 	}
 	/**
 	* Resolves the RPC call with the provided value.
@@ -34,20 +79,42 @@ var IRPCCall = class {
 	*/
 	resolve(value) {
 		if (this.resolved) return;
+		this.value = value;
+		this.status = IRPC_STATUS.SUCCESS;
 		this.resolved = true;
-		this.resolver(value);
+		this.finishedAt = Date.now();
+		clearTimeout(this.timerId);
 	}
 	/**
 	* Rejects the RPC call with the provided reason.
 	* If the call is already resolved, this method does nothing.
 	* @param reason - Optional error reason for rejecting the promise
+	* @param retriable - Flag indicating whether to retry the call
 	*/
-	reject(reason) {
+	reject(reason, retriable = true) {
 		if (this.resolved) return;
-		this.resolved = true;
-		this.rejector(reason);
+		const { maxRetries, retryMode = DEFAULT_RETRY_MODE, retryDelay = DEFAULT_RETRY_DELAY } = this.options;
+		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);
+				this.reject(reason, false);
+				return;
+			}
+			const delay = retryMode === "linear" ? retryDelay : retryDelay * 2 ** this.retries;
+			setTimeout(() => {
+				this.retries++;
+				this.transport.schedule(this);
+			}, delay);
+		} else {
+			this.error = reason;
+			this.status = IRPC_STATUS.ERROR;
+			this.resolved = true;
+			this.finishedAt = Date.now();
+			clearTimeout(this.timerId);
+		}
 	}
 };
 
 //#endregion
-export { IRPCCall };
+export { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, IRPCCall };

package/dist/enum.d.ts

@@ -0,0 +1,35 @@
+//#region src/enum.d.ts
+declare const IRPC_PACKET_TYPE: {
+  readonly CALL: "call";
+  readonly EVENT: "event";
+  readonly CLOSE: "close";
+  readonly ANSWER: "answer";
+  readonly REQUEST: "request";
+  readonly RESPONSE: "response";
+};
+declare const IRPC_DATA_TYPE: {
+  readonly ARRAY: "array";
+  readonly OBJECT: "object";
+  readonly READABLE: "readable";
+  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";
+};
+//#endregion
+export { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS };

package/dist/enum.js

@@ -0,0 +1,36 @@
+//#region src/enum.ts
+const IRPC_PACKET_TYPE = {
+	CALL: "call",
+	EVENT: "event",
+	CLOSE: "close",
+	ANSWER: "answer",
+	REQUEST: "request",
+	RESPONSE: "response"
+};
+const IRPC_DATA_TYPE = {
+	ARRAY: "array",
+	OBJECT: "object",
+	READABLE: "readable",
+	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"
+};
+
+//#endregion
+export { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS };

package/dist/error.d.ts

@@ -22,6 +22,8 @@ declare const ERROR_CODE: {
   RESOLVER_NOT_IMPLEMENTED: string;
   RESOLVER_NOT_FOUND: string;
   RESOLVER_NOT_SUPPORTED: string;
+  STREAM_ERROR: string;
+  CALL_MAX_RETRIES_REACHED: string;
 };
 type ErrorCode = (typeof ERROR_CODE)[keyof typeof ERROR_CODE];
 declare const ERROR_MESSAGE: {
@@ -41,10 +43,13 @@ declare const ERROR_MESSAGE: {
   [ERROR_CODE.TRANSPORT_INVALID]: string;
   [ERROR_CODE.TRANSPORT_NOT_IMPLEMENTED]: string;
   [ERROR_CODE.STUB_INVALID]: string;
+  [ERROR_CODE.STREAM_ERROR]: string;
   [ERROR_CODE.STUB_NOT_IMPLEMENTED]: string;
   [ERROR_CODE.RESOLVER_MISSING]: string;
   [ERROR_CODE.RESOLVER_NOT_IMPLEMENTED]: string;
   [ERROR_CODE.RESOLVER_NOT_FOUND]: string;
+  [ERROR_CODE.RESOLVER_NOT_SUPPORTED]: string;
+  [ERROR_CODE.CALL_MAX_RETRIES_REACHED]: string;
 };
 //#endregion
 export { ERROR_CODE, ERROR_MESSAGE, ErrorCode };

package/dist/error.js

@@ -21,7 +21,9 @@ const ERROR_CODE = {
 	RESOLVER_MISSING: "resolver_missing",
 	RESOLVER_NOT_IMPLEMENTED: "resolver_not_implemented",
 	RESOLVER_NOT_FOUND: "resolver_not_found",
-	RESOLVER_NOT_SUPPORTED: "resolver_not_supported"
+	RESOLVER_NOT_SUPPORTED: "resolver_not_supported",
+	STREAM_ERROR: "stream_error",
+	CALL_MAX_RETRIES_REACHED: "call_max_retries_reached"
 };
 const ERROR_MESSAGE = {
 	[ERROR_CODE.UNKNOWN]: "IRPC: Unknown error",
@@ -40,10 +42,13 @@ const ERROR_MESSAGE = {
 	[ERROR_CODE.TRANSPORT_INVALID]: "IRPC: Transport invalid error",
 	[ERROR_CODE.TRANSPORT_NOT_IMPLEMENTED]: "IRPC: Transport not implemented error",
 	[ERROR_CODE.STUB_INVALID]: "IRPC: Stub invalid error",
+	[ERROR_CODE.STREAM_ERROR]: "IRPC: Stream error",
 	[ERROR_CODE.STUB_NOT_IMPLEMENTED]: "IRPC: Stub not implemented error",
 	[ERROR_CODE.RESOLVER_MISSING]: "IRPC: Resolver missing error",
 	[ERROR_CODE.RESOLVER_NOT_IMPLEMENTED]: "IRPC: Resolver not implemented error",
-	[ERROR_CODE.RESOLVER_NOT_FOUND]: "IRPC: Resolver not found error"
+	[ERROR_CODE.RESOLVER_NOT_FOUND]: "IRPC: Resolver not found error",
+	[ERROR_CODE.RESOLVER_NOT_SUPPORTED]: "IRPC: Resolver not supported error",
+	[ERROR_CODE.CALL_MAX_RETRIES_REACHED]: "IRPC: Call max retries reached error"
 };
 
 //#endregion

package/dist/index.d.ts

@@ -1,9 +1,13 @@
 import { IRPCCacheEntry, IRPCCacher } from "./cache.js";
+import { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE, ErrorCode } from "./error.js";
 import { IRPCTransport } from "./transport.js";
-import { IRPCArraySchema, IRPCCache, IRPCCaches, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCError, IRPCHandler, IRPCInit, IRPCInputs, IRPCModule, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStubStore, TransportConfig } from "./types.js";
-import { IRPCCall } from "./call.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 { 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 { IRPCResolver } from "./resolver.js";
-export { ERROR_CODE, ERROR_MESSAGE, ErrorCode, IRPCArraySchema, IRPCCache, IRPCCacheEntry, IRPCCacher, IRPCCaches, IRPCCall, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCError, IRPCHandler, IRPCInit, IRPCInputs, IRPCModule, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackage, IRPCPackageConfig, IRPCPackageInfo, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRequest, IRPCResolver, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStubStore, IRPCTransport, TransportConfig, createContext, createPackage, getContext, setContext, setContextProvider, withContext };
+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 };

package/dist/index.js

@@ -1,9 +1,13 @@
 import { IRPCCacher } from "./cache.js";
-import { IRPCCall } from "./call.js";
-import { createContext, getContext, setContext, setContextProvider, withContext } from "./context.js";
+import { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE } from "./error.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 { IRPCStream } from "./stream.js";
 
-export { ERROR_CODE, ERROR_MESSAGE, IRPCCacher, IRPCCall, IRPCPackage, IRPCResolver, IRPCTransport, createContext, createPackage, getContext, setContext, setContextProvider, withContext };
+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 };

package/dist/module.d.ts

@@ -1,6 +1,7 @@
 import { IRPCCacher } from "./cache.js";
 import { IRPCTransport } from "./transport.js";
-import { IRPCData, IRPCHandler, IRPCInit, IRPCInputs, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCRequest, IRPCSpec, IRPCSpecStore, IRPCStubStore } from "./types.js";
+import { IRPCData, IRPCDeclareInit, IRPCHandler, IRPCInputs, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCRequest, IRPCSpec, IRPCSpecStore, IRPCStubStore } from "./types.js";
+import { RemoteState } from "./state.js";
 
 //#region src/module.d.ts
 
@@ -46,18 +47,18 @@ declare class IRPCPackage {
   constructor(config?: Partial<IRPCPackageConfig>);
   /**
    * Declares a new IRPC specification and creates a corresponding stub function
-   * @param init - The initialization object containing the IRPC specification
+   * @param options - The initialization object containing the IRPC specification
    * @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>(init: IRPCInit<I, O>): F;
+  declare<F, I extends IRPCInputs = IRPCInputs, O extends IRPCOutput = IRPCOutput>(options: IRPCDeclareInit<F, I, O>): F;
   /**
    * Resolves and executes an IRPC call based on a request object
    * @param req - The request containing the IRPC name and arguments
    * @returns The result of the IRPC execution
    * @throws Error if the IRPC doesn't exist or doesn't have an implementation
    */
-  resolve(req: IRPCRequest): Promise<IRPCData>;
+  resolve(req: IRPCRequest): IRPCData | Promise<IRPCData> | RemoteState<IRPCData>;
   /**
    * Associates a handler function with a stub function
    * @param stub - The stub function created by declare()

package/dist/module.js

@@ -1,5 +1,6 @@
 import { IRPCCacher } from "./cache.js";
 import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { RemoteState } from "./state.js";
 import { IRPCTransport } from "./transport.js";
 
 //#region src/module.ts
@@ -65,29 +66,40 @@ var IRPCPackage = class {
 	}
 	/**
 	* Declares a new IRPC specification and creates a corresponding stub function
-	* @param init - The initialization object containing the IRPC specification
+	* @param options - The initialization object containing the IRPC specification
 	* @returns A stub function that can be used to call the IRPC
 	* @throws Error if an IRPC with the same name already exists
 	*/
-	declare(init) {
-		if (this.specs.has(init.name)) throw new Error(`IRPC ${init.name} already exists.`);
-		const spec = { ...init };
+	declare(options) {
+		if (this.specs.has(options.name)) throw new Error(`IRPC ${options.name} already exists.`);
+		const spec = { ...options };
+		const calls = /* @__PURE__ */ new Map();
 		const caches = new IRPCCacher();
-		const timeout = spec.timeout ?? this.config.timeout;
-		const stub = (async (...args) => {
-			if (typeof spec.handler === "function") return spec.handler(...args);
-			if (!this.transport) throw new Error(ERROR_MESSAGE[ERROR_CODE.TRANSPORT_MISSING]);
-			if (spec.maxAge) {
-				const key = JSON.stringify(args);
-				const cache = caches.get(key);
-				if (cache) return cache.value;
-				const data = await this.transport.call(spec, args, timeout);
-				caches.set(key, data, spec.maxAge);
-				return data;
-			}
-			return await this.transport.call(spec, args, timeout);
+		const stub = ((...args) => {
+			if (!this.transport && typeof spec.handler !== "function") return Promise.reject(new Error(ERROR_MESSAGE[ERROR_CODE.TRANSPORT_MISSING]));
+			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 } = {
+				...this.config,
+				...spec
+			};
+			const config = {
+				timeout,
+				maxRetries,
+				retryDelay,
+				retryMode
+			};
+			const call = typeof spec.handler === "function" ? spec.handler(...args) : this.transport.call(spec, args, config);
+			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(init.name, spec);
+		this.specs.set(options.name, spec);
 		this.stubs.set(stub, spec);
 		this.cache.set(stub, caches);
 		return stub;
@@ -98,11 +110,11 @@ var IRPCPackage = class {
 	* @returns The result of the IRPC execution
 	* @throws Error if the IRPC doesn't exist or doesn't have an implementation
 	*/
-	async resolve(req) {
+	resolve(req) {
 		const spec = this.specs.get(req.name);
 		if (!spec) return Promise.reject(/* @__PURE__ */ new Error(`IRPC ${req.name} does not exist.`));
 		if (typeof spec.handler !== "function") return Promise.reject(/* @__PURE__ */ new Error(`IRPC ${req.name} does not have an implementation.`));
-		return await spec.handler(...req.args);
+		return spec.handler(...req.args);
 	}
 	/**
 	* Associates a handler function with a stub function

package/dist/reader.d.ts

@@ -0,0 +1,24 @@
+import { IRPCData, IRPCPacketStream } from "./types.js";
+import { RemoteState } from "./state.js";
+
+//#region src/reader.d.ts
+
+/**
+ * A client-side consumer that hydrates `RemoteState` instances from network stream packets.
+ *
+ * @template T - The type of data yielded by the stream.
+ */
+declare class IRPCReader<T extends IRPCData> extends RemoteState<T> {
+  id: string;
+  packets: Set<IRPCPacketStream<T>>;
+  constructor(id: string, init?: T);
+  /**
+   * Pushes incoming network packets into this reader, evaluating payload data
+   * and subsequently updating the core state values locally.
+   *
+   * @param packet - The incoming unified Stream Packet structure (`ANSWER`, `EVENT`, or `CLOSE`).
+   */
+  push(packet: IRPCPacketStream<T>): void;
+}
+//#endregion
+export { IRPCReader };

package/dist/reader.js

@@ -0,0 +1,37 @@
+import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
+import { RemoteState } from "./state.js";
+import { replay } from "@anchorlib/core";
+
+//#region src/reader.ts
+/**
+* A client-side consumer that hydrates `RemoteState` instances from network stream packets.
+*
+* @template T - The type of data yielded by the stream.
+*/
+var IRPCReader = class extends RemoteState {
+	packets = /* @__PURE__ */ new Set();
+	constructor(id, init) {
+		super(init);
+		this.id = id;
+	}
+	/**
+	* Pushes incoming network packets into this reader, evaluating payload data
+	* and subsequently updating the core state values locally.
+	*
+	* @param packet - The incoming unified Stream Packet structure (`ANSWER`, `EVENT`, or `CLOSE`).
+	*/
+	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);
+		else if (packet.type === IRPC_PACKET_TYPE.CLOSE) {
+			if (packet.error) this.error = new Error(packet.error.message);
+		}
+		this.status = packet.status;
+	}
+};
+
+//#endregion
+export { IRPCReader };

package/dist/resolver.d.ts

@@ -1,4 +1,4 @@
-import { IRPCDataSchema, IRPCError, IRPCInputs, IRPCOutput, IRPCRequest, IRPCResponse, IRPCSpec } from "./types.js";
+import { IRPCDataSchema, IRPCInputs, IRPCOutput, IRPCRequest, IRPCResponse, IRPCSpec } from "./types.js";
 import { IRPCPackage } from "./module.js";
 
 //#region src/resolver.d.ts
@@ -45,17 +45,7 @@ declare class IRPCResolver {
     id,
     name,
     args
-  }: IRPCRequest, schema?: IRPCOutput): Promise<{
-    id: string;
-    name: string;
-    result: string | number | boolean | IRPCDataSchema | Record<string, unknown> | (string | number | boolean | Record<string, unknown> | null | undefined)[] | null | undefined;
-    error?: undefined;
-  } | {
-    id: string;
-    name: string;
-    error: IRPCError;
-    result?: undefined;
-  }>;
+  }: IRPCRequest, schema?: IRPCOutput): Promise<IRPCResponse>;
 }
 //#endregion
 export { IRPCResolver };

package/dist/resolver.js

@@ -1,4 +1,5 @@
 import { ERROR_CODE } from "./error.js";
+import { RemoteState } from "./state.js";
 
 //#region src/resolver.ts
 /**
@@ -69,11 +70,28 @@ var IRPCResolver = class {
 	*/
 	async forward({ id, name, args }, schema) {
 		try {
-			const output = parseOutput(await this.module.resolve({
+			const result = this.module.resolve({
 				id,
 				name,
 				args
-			}), schema);
+			});
+			if (result instanceof RemoteState) {
+				const output$1 = parseOutput(result.data, schema);
+				if (!output$1.success) return {
+					id,
+					name,
+					error: {
+						code: ERROR_CODE.INVALID_OUTPUT,
+						message: output$1.error?.message
+					}
+				};
+				return {
+					id,
+					name,
+					result
+				};
+			}
+			const output = parseOutput(await result, schema);
 			if (output.success) return {
 				id,
 				name,