@irpclib/irpc 1.0.0-beta.24 → 1.0.0

package/dist/module.js

@@ -1,6 +1,6 @@
+import { HandlerError, ResolveError, StubError, TransportError } from "./error.js";
 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";
@@ -37,6 +37,7 @@ var IRPCPackage = class {
 	config = {
 		name: "global",
 		version: "1.0.0",
+		key: "id",
 		timeout: DEFAULT_TIMEOUT
 	};
 	/**
@@ -71,23 +72,29 @@ var IRPCPackage = class {
 		this.configure(config ?? {});
 		IRPC_STORE.register(this);
 	}
-	/**
-	* Declares a new IRPC specification and creates a corresponding stub function
-	* @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(options) {
+	declare(nameOrOptions, seedOrConfig, config) {
+		let options;
+		if (typeof nameOrOptions === "string") if (typeof seedOrConfig === "function") options = {
+			name: nameOrOptions,
+			seed: seedOrConfig,
+			...config
+		};
+		else options = {
+			name: nameOrOptions,
+			...seedOrConfig
+		};
+		else options = nameOrOptions;
 		const $options = options;
-		if (this.specs.has($options.name)) throw new Error(`IRPC ${$options.name} already exists.`);
+		if (this.specs.has($options.name)) throw StubError.duplicate($options.name);
+		if ($options.init && !$options.seed) $options.seed = $options.init;
 		const spec = {
-			init: () => void 0,
+			seed: () => void 0,
 			...$options
 		};
 		const calls = /* @__PURE__ */ new Map();
 		const caches = new IRPCCacher();
 		const stub = ((...args) => {
-			return execute(args, new IRPCReader(uuid(), spec.init()));
+			return execute(args, new IRPCReader(uuid(), spec.seed()));
 		});
 		/** Browser only stub for single immediate execution **/
 		stub.once = (...args) => {
@@ -100,7 +107,7 @@ var IRPCPackage = class {
 			return prepare(typeof getArgs === "function" ? getArgs : () => getArgs, true, debounce);
 		};
 		stub.later = (debounce) => {
-			const reader = new IRPCReader(uuid(), spec.init(), IRPC_STATUS.IDLE, true);
+			const reader = new IRPCReader(uuid(), spec.seed(), IRPC_STATUS.IDLE, true);
 			if (debounce) {
 				const [schedule, cancel] = microtask(debounce);
 				reader.dispatch = (...args) => schedule(() => {
@@ -125,7 +132,7 @@ var IRPCPackage = class {
 		* @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);
+			const reader = new IRPCReader(uuid(), spec.seed(), deferred ? IRPC_STATUS.IDLE : IRPC_STATUS.PENDING);
 			if (isBrowser()) {
 				const observer = createObserver(() => {
 					observer.reset();
@@ -149,29 +156,28 @@ var IRPCPackage = class {
 			return reader;
 		}
 		const execute = (args, reader) => {
-			if (!this.transport && typeof spec.handler !== "function") return Promise.reject(new Error(ERROR_MESSAGE[ERROR_CODE.TRANSPORT_MISSING]));
+			if (!this.transport && typeof spec.handler !== "function") return Promise.reject(TransportError.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, init } = {
+			const { timeout, maxRetries, retryDelay, retryMode } = {
 				...this.config,
 				...spec
 			};
-			const config = {
+			const config$1 = {
 				timeout,
 				maxRetries,
 				retryDelay,
-				retryMode,
-				init
+				retryMode
 			};
 			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);
+			const call = typeof spec.handler === "function" ? intercept(spec, args, reader) : this.transport.call(spec, args, config$1, reader);
 			calls.set(callKey, call);
 			if (spec.maxAge) caches.set(callKey, call, spec.maxAge);
 			onCleanup(() => call.close());
@@ -185,6 +191,50 @@ var IRPCPackage = class {
 		return stub;
 	}
 	/**
+	* Declares CRUD stubs (get, create, update, delete) for an entity
+	* @param name - The entity name used as prefix for stub names
+	* @param seed - Factory function returning a default entity instance
+	* @param options - Optional configuration for caching, schemas, and call behavior
+	* @returns An object containing the four CRUD stub functions
+	*/
+	crud(name, seed, options) {
+		const { description, schema, maxAge, coalesce,...callConfig } = options ?? {};
+		const desc = (method) => typeof description === "string" ? description : description?.[method];
+		const init = (method) => ({
+			...callConfig,
+			name: `${name}.${method}`,
+			seed,
+			description: desc(method),
+			schema: schema?.[method],
+			...method === "get" ? { maxAge } : {},
+			coalesce
+		});
+		return {
+			get: this.declare(init("get")),
+			create: this.declare(init("create")),
+			update: this.declare(init("update")),
+			delete: this.declare(init("delete"))
+		};
+	}
+	/**
+	* Removes CRUD methods from a stubs object and unregisters their specs
+	* @param stubs - The CRUD stubs object to modify
+	* @param keys - The method names to remove
+	* @returns The stubs object without the excluded methods
+	*/
+	exclude(stubs, keys) {
+		for (const key of keys) {
+			const stub = stubs[key];
+			if (stub) {
+				const spec = this.stubs.get(stub);
+				if (spec) this.specs.delete(spec.name);
+				this.stubs.delete(stub);
+			}
+			delete stubs[key];
+		}
+		return stubs;
+	}
+	/**
 	* 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
@@ -192,8 +242,8 @@ var IRPCPackage = class {
 	*/
 	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.`));
+		if (!spec) return Promise.reject(ResolveError.notFound(req.name));
+		if (typeof spec.handler !== "function") return Promise.reject(HandlerError.missing(req.name));
 		return spec.handler(...req.args);
 	}
 	/**
@@ -204,28 +254,28 @@ var IRPCPackage = class {
 	* @throws Error if the stub or handler is invalid, or if no IRPC exists for the stub
 	*/
 	construct(stub, handler) {
-		if (typeof stub !== "function") throw new Error(ERROR_MESSAGE[ERROR_CODE.STUB_INVALID]);
-		if (typeof handler !== "function") throw new Error(ERROR_MESSAGE[ERROR_CODE.INVALID_HANDLER]);
+		if (typeof stub !== "function") throw StubError.invalid();
+		if (typeof handler !== "function") throw HandlerError.invalid();
 		const spec = this.stubs.get(stub);
-		if (!spec?.name) throw new Error(ERROR_MESSAGE[ERROR_CODE.NOT_FOUND]);
+		if (!spec?.name) throw StubError.notFound();
 		spec.handler = handler;
 		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);
+	hook(stubOrGroup, handler) {
+		if (typeof stubOrGroup === "function") {
+			if (!this.stubs.has(stubOrGroup)) {
+				const error = StubError.notFound();
+				IRPC_STORE.error(error);
+				return this;
+			}
+			const spec = this.stubs.get(stubOrGroup);
+			this.hooks.get(spec).add(handler);
 			return this;
 		}
-		const spec = this.stubs.get(stub);
-		this.hooks.get(spec).add(handler);
+		for (const stub of Object.values(stubOrGroup)) if (typeof stub === "function" && this.stubs.has(stub)) {
+			const spec = this.stubs.get(stub);
+			this.hooks.get(spec).add(handler);
+		}
 		return this;
 	}
 	/**
@@ -236,7 +286,7 @@ var IRPCPackage = class {
 	*/
 	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]);
+		if (!spec || !this.hooks.has(spec)) throw StubError.notFound();
 		const hooks = this.hooks.get(spec);
 		for (const hook of hooks) await hook(req);
 	}
@@ -247,7 +297,7 @@ var IRPCPackage = class {
 	* @throws Error if the transport is not a valid Transport instance
 	*/
 	use(transport) {
-		if (!(transport instanceof IRPCTransport)) throw new Error(ERROR_MESSAGE[ERROR_CODE.TRANSPORT_INVALID]);
+		if (!(transport instanceof IRPCTransport)) throw TransportError.invalid();
 		if (this.transport) this.transport.modules.delete(this);
 		transport.modules.add(this);
 		this.config.transport = transport;
@@ -269,8 +319,8 @@ var IRPCPackage = class {
 	* @throws Error if the provided name or version is invalid
 	*/
 	configure(config) {
-		if (config.name && !NAME_CONSTRAINT.test(config.name)) throw new Error(`Invalid IRPC name: ${config.name}`);
-		if (config.version && !VERSION_CONSTRAINT.test(config.version)) throw new Error(`Invalid IRPC version: ${config.version}`);
+		if (config.name && !NAME_CONSTRAINT.test(config.name)) throw StubError.invalidName(config.name);
+		if (config.version && !VERSION_CONSTRAINT.test(config.version)) throw StubError.invalidVersion(config.version);
 		Object.assign(this.config, config);
 		return this;
 	}

package/dist/reader.js

@@ -1,3 +1,4 @@
+import { IRPCError } from "./error.js";
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { RemoteState } from "./state.js";
 import { replay } from "@anchorlib/core";
@@ -30,11 +31,11 @@ var IRPCReader = class extends RemoteState {
 	*/
 	push(packet) {
 		packet.arrivedAt = Date.now();
-		if (packet.type === IRPC_PACKET_TYPE.ANSWER) if (packet.status === IRPC_STATUS.ERROR) this.error = new Error(packet.error.message);
+		if (packet.type === IRPC_PACKET_TYPE.ANSWER) if (packet.status === IRPC_STATUS.ERROR) this.error = IRPCError.from(packet.error);
 		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);
+			if (packet.error) this.error = IRPCError.from(packet.error);
 		}
 		this.status = packet.status;
 	}

package/dist/resolver.d.ts

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

package/dist/resolver.js

@@ -1,4 +1,4 @@
-import { ERROR_CODE } from "./error.js";
+import { HandlerError, ResolveError } from "./error.js";
 import { RemoteState } from "./state.js";
 
 //#region src/resolver.ts
@@ -40,20 +40,14 @@ var IRPCResolver = class {
 		if (!this.spec) return {
 			id,
 			name,
-			error: {
-				code: ERROR_CODE.NOT_FOUND,
-				message: `IRPC "${name}" does not exist.`
-			}
+			error: ResolveError.notFound(name).json()
 		};
 		const { schema } = this.spec;
 		const inputs = parseInput(args, schema?.input);
 		if (!inputs.success) return {
 			id,
 			name,
-			error: {
-				code: ERROR_CODE.INVALID_INPUT,
-				message: inputs.error
-			}
+			error: ResolveError.invalidInput(inputs.error).json()
 		};
 		return this.forward({
 			id,
@@ -85,10 +79,7 @@ var IRPCResolver = class {
 				if (!output$1.success) return {
 					id,
 					name,
-					error: {
-						code: ERROR_CODE.INVALID_OUTPUT,
-						message: output$1.error?.message
-					}
+					error: ResolveError.invalidOutput(output$1.error).json()
 				};
 				return {
 					id,
@@ -103,10 +94,7 @@ var IRPCResolver = class {
 				if (!output$1.success) return {
 					id,
 					name,
-					error: {
-						code: ERROR_CODE.INVALID_OUTPUT,
-						message: output$1.error?.message
-					}
+					error: ResolveError.invalidOutput(output$1.error).json()
 				};
 				return {
 					id,
@@ -123,19 +111,13 @@ var IRPCResolver = class {
 			else return {
 				id,
 				name,
-				error: {
-					code: ERROR_CODE.INVALID_OUTPUT,
-					message: output.error?.message
-				}
+				error: ResolveError.invalidOutput(output.error).json()
 			};
 		} catch (error) {
 			return {
 				id,
 				name,
-				error: {
-					code: ERROR_CODE.HANDLER_ERROR,
-					message: error.message
-				}
+				error: HandlerError.failed(error).json()
 			};
 		}
 	}

package/dist/router.d.ts

@@ -1,6 +1,6 @@
-import { IRPCPackage } from "./module.js";
 import { IRPCTransport } from "./transport.js";
-import { IRPCRequest } from "./types.js";
+import { IRPCPacketError, IRPCRequest } from "./types.js";
+import { IRPCPackage } from "./module.js";
 
 //#region src/router.d.ts
 type IRPCHook = () => void | Promise<void>;
@@ -42,10 +42,7 @@ declare class IRPCRouter {
     name: string;
     type: "close";
     status: "error";
-    error: {
-      code: string;
-      message: string;
-    };
+    error: IRPCPacketError;
     createdAt: number;
   } | undefined>;
 }

package/dist/router.js

@@ -1,5 +1,5 @@
+import { HookError } from "./error.js";
 import { IRPC_BASE_CONTEXT, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
-import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
 import { createContextStore, withContext } from "./context.js";
 import { IRPC_STORE } from "./store.js";
 
@@ -24,7 +24,7 @@ var IRPCRouter = class {
 	*/
 	use(hook) {
 		if (typeof hook !== "function") {
-			const error = new Error(ERROR_MESSAGE[ERROR_CODE.INVALID_HOOK]);
+			const error = HookError.invalid();
 			IRPC_STORE.error(error);
 			return this;
 		}
@@ -67,10 +67,7 @@ var IRPCRouter = class {
 				name: req.name,
 				type: IRPC_PACKET_TYPE.CLOSE,
 				status: IRPC_STATUS.ERROR,
-				error: {
-					code: ERROR_CODE.UNKNOWN,
-					message: ERROR_MESSAGE[ERROR_CODE.UNKNOWN]
-				},
+				error: HookError.failed(error).json(),
 				createdAt: Date.now()
 			};
 		}

package/dist/state.d.ts

@@ -1,6 +1,5 @@
 import { IRPCReadable, IRPCStatus, StreamConstructor } from "./types.js";
-import * as _anchorlib_core0 from "@anchorlib/core";
-import { StateSubscriber } from "@anchorlib/core";
+import { StateSubscriber, StateUnsubscribe } from "@anchorlib/core";
 
 //#region src/state.d.ts
 
@@ -41,8 +40,21 @@ declare class RemoteState<T> extends Promise<T> {
    * @param resumable - Whether the state should be resumable after being closed.
    */
   constructor(init?: T, status?: IRPCStatus, resumable?: boolean | undefined);
+  /**
+   * Transitions the state to SUCCESS and resolves the underlying Promise.
+   *
+   * @param value - Optional final value to resolve with.
+   */
   accept(value?: T): void;
+  /**
+   * Transitions the state to ERROR and rejects the underlying Promise.
+   *
+   * @param error - Optional error to reject with.
+   */
   reject(error?: Error): void;
+  /**
+   * Aborts the current execution, transitioning the status to ABORTED.
+   */
   abort(): void;
   /**
    * Subscribes to changes emitted by the internal state.
@@ -50,14 +62,34 @@ declare class RemoteState<T> extends Promise<T> {
    * @param handler - A callback function invoked whenever the state mutates.
    * @returns An unsubscribe function to terminate the listener.
    */
-  subscribe(handler: StateSubscriber<IRPCReadable<T>>): _anchorlib_core0.StateUnsubscribe;
+  subscribe(handler: StateSubscriber<IRPCReadable<T>>): StateUnsubscribe;
   /**
    * Closes the reactive state and terminates the underlying Promise.
    */
   close(): void;
+  /**
+   * Resumes a closed state if it was marked as resumable.
+   */
   protected resume(): void;
+  /**
+   * Temporarily disables the `.then()` method to prevent automatic Promise chaining.
+   *
+   * @returns The current instance for chaining.
+   */
   pipe(): this;
+  /**
+   * Restores the `.then()` method if it was previously locked via `.pipe()`.
+   *
+   * @returns The current instance for chaining.
+   */
   unpipe(): this;
+  /**
+   * Pipes all state mutations from this instance to a target RemoteState.
+   *
+   * @param target - The destination RemoteState to receive the updates.
+   * @returns The current instance for chaining.
+   */
+  pipeTo(target: RemoteState<T>): this;
   /**
    * Destroys the reactive state bindings.
    */
@@ -75,9 +107,9 @@ declare class RemoteState<T> extends Promise<T> {
  *
  * @template T - The type of the streamed payload data.
  * @param construct - The isolated stream constructor callback that natively operates the pipeline.
- * @param init - An optional initial value to prime the state payload inherently.
+ * @param seed - An optional initial value to prime the state payload inherently.
  * @returns A fully active RemoteState inherently bound to the callbacks executing natively.
  */
-declare function stream<T>(construct: StreamConstructor<T>, init?: T): RemoteState<T>;
+declare function stream<T>(construct: StreamConstructor<T>, seed?: T): RemoteState<T>;
 //#endregion
 export { RemoteState, stream };

package/dist/state.js

@@ -1,7 +1,7 @@
+import { IRPCError, IRPC_ERROR_TYPE } from "./error.js";
 import { IRPC_STATUS } from "./enum.js";
-import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
 import { getAbortSignal } from "./context.js";
-import { $do, anchor, mutable, onCleanup, subscribe } from "@anchorlib/core";
+import { $do, anchor, mutable, onCleanup, replay, subscribe } from "@anchorlib/core";
 
 //#region src/state.ts
 /**
@@ -17,6 +17,7 @@ var RemoteState = class extends Promise {
 	#state;
 	#accept;
 	#reject;
+	#pipes = /* @__PURE__ */ new Set();
 	#closed = false;
 	#locked;
 	get state() {
@@ -97,10 +98,13 @@ var RemoteState = class extends Promise {
 			if (args.length) this.#state.error = args[0];
 			this.#closed = true;
 			this.#state.status = IRPC_STATUS.ERROR;
-			this.#reject(this.error ?? new Error(ERROR_MESSAGE[ERROR_CODE.UNKNOWN]));
+			this.#reject(this.error ?? new IRPCError(IRPC_ERROR_TYPE.CALL, "unknown", "Unknown error."));
 			this.destroy();
 		});
 	}
+	/**
+	* Aborts the current execution, transitioning the status to ABORTED.
+	*/
 	abort() {
 		$do(() => {
 			this.#closed = true;
@@ -116,7 +120,9 @@ var RemoteState = class extends Promise {
 	* @returns An unsubscribe function to terminate the listener.
 	*/
 	subscribe(handler) {
-		return subscribe(this.state, handler);
+		const unsubscribe = subscribe(this.state, handler);
+		this.#pipes.add(unsubscribe);
+		return unsubscribe;
 	}
 	/**
 	* Closes the reactive state and terminates the underlying Promise.
@@ -127,14 +133,27 @@ var RemoteState = class extends Promise {
 		this.#accept(this.data);
 		this.destroy();
 	}
+	/**
+	* Resumes a closed state if it was marked as resumable.
+	*/
 	resume() {
 		this.#closed = false;
 	}
+	/**
+	* Temporarily disables the `.then()` method to prevent automatic Promise chaining.
+	*
+	* @returns The current instance for chaining.
+	*/
 	pipe() {
 		this.#locked = this.then;
 		this.then = void 0;
 		return this;
 	}
+	/**
+	* Restores the `.then()` method if it was previously locked via `.pipe()`.
+	*
+	* @returns The current instance for chaining.
+	*/
 	unpipe() {
 		if (!this.#locked) return this;
 		this.then = this.#locked;
@@ -142,10 +161,28 @@ var RemoteState = class extends Promise {
 		return this;
 	}
 	/**
+	* Pipes all state mutations from this instance to a target RemoteState.
+	*
+	* @param target - The destination RemoteState to receive the updates.
+	* @returns The current instance for chaining.
+	*/
+	pipeTo(target) {
+		this.subscribe((_, event) => {
+			if (event.type === "init") {
+				anchor.assign(target.state, this.state);
+				return;
+			}
+			replay(target.state, event);
+		});
+		return this;
+	}
+	/**
 	* Destroys the reactive state bindings.
 	*/
 	destroy() {
 		if (this.resumable) return;
+		for (const unsubscribe of this.#pipes) unsubscribe();
+		this.#pipes.clear();
 		anchor.destroy(this.state);
 	}
 	/**
@@ -163,11 +200,11 @@ var RemoteState = class extends Promise {
 *
 * @template T - The type of the streamed payload data.
 * @param construct - The isolated stream constructor callback that natively operates the pipeline.
-* @param init - An optional initial value to prime the state payload inherently.
+* @param seed - An optional initial value to prime the state payload inherently.
 * @returns A fully active RemoteState inherently bound to the callbacks executing natively.
 */
-function stream(construct, init) {
-	const state = new RemoteState(init);
+function stream(construct, seed) {
+	const state = new RemoteState(seed);
 	const abortSignal = getAbortSignal();
 	const accept = ((...values) => {
 		if (values.length > 0) state.data = values[0];

package/dist/store.d.ts

@@ -1,6 +1,6 @@
 import { IRPC_STORE_EVENT } from "./enum.js";
-import { IRPCPackage } from "./module.js";
 import { IRPCData } from "./types.js";
+import { IRPCPackage } from "./module.js";
 import { IRPCRouter } from "./router.js";
 import { IRPCStream } from "./stream.js";
 
@@ -27,7 +27,7 @@ declare class IRPCStore {
   #private;
   calls: Set<IRPCStream<IRPCData>>;
   routers: Set<IRPCRouter>;
-  packages: Set<IRPCPackage>;
+  packages: Set<IRPCPackage<"id">>;
   callCount: number;
   errorCount: number;
   register(pkg: IRPCPackage): void;

package/dist/stream.d.ts

@@ -1,4 +1,4 @@
-import { IRPCData, IRPCDataSchema, IRPCError, IRPCInputs, IRPCPacketStream, IRPCResponse, IRPCSpec, IRPCStatus } from "./types.js";
+import { IRPCData, IRPCDataSchema, IRPCInputs, IRPCPacketError, IRPCPacketStream, IRPCResponse, IRPCSpec, IRPCStatus } from "./types.js";
 import { IRPCRouter } from "./router.js";
 
 //#region src/stream.d.ts
@@ -21,7 +21,7 @@ declare class IRPCStream<T extends IRPCData> {
   private closeHandlers;
   private errorHandlers;
   value?: T;
-  error?: IRPCError;
+  error?: IRPCPacketError;
   status: IRPCStatus;
   closed: boolean;
   createdAt: number;
@@ -55,7 +55,7 @@ declare class IRPCStream<T extends IRPCData> {
    *
    * @param handler - A callback function to receive stream errors.
    */
-  catch(handler: (error: IRPCError) => void): void;
+  catch(handler: (error: IRPCPacketError) => void): void;
   /**
    * Binds a handler triggered upon terminal completion of the stream process (success or error).
    *

package/dist/stream.js

@@ -1,5 +1,5 @@
+import { CallError, HandlerError, ResolveError } from "./error.js";
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
-import { ERROR_CODE } from "./error.js";
 import { getAbortController, getAbortSignal } from "./context.js";
 import { RemoteState } from "./state.js";
 import { IRPC_STORE } from "./store.js";
@@ -68,10 +68,7 @@ var IRPCStream = class {
 				this.value = result.data;
 				if (result.status === IRPC_STATUS.SUCCESS || result.status === IRPC_STATUS.ERROR) {
 					if (result.status === IRPC_STATUS.ERROR) {
-						this.error = {
-							code: ERROR_CODE.HANDLER_ERROR,
-							message: result.error.message
-						};
+						this.error = HandlerError.failed(result.error).json();
 						this.status = IRPC_STATUS.ERROR;
 					} else this.status = IRPC_STATUS.SUCCESS;
 					const packet = {
@@ -119,10 +116,7 @@ var IRPCStream = class {
 						if (state.status !== IRPC_STATUS.SUCCESS && state.status !== IRPC_STATUS.ERROR) return;
 						this.status = state.status;
 						if (state.status === IRPC_STATUS.ERROR) {
-							this.error = {
-								code: ERROR_CODE.STREAM_ERROR,
-								message: state.error.message
-							};
+							this.error = CallError.streamError(state.error).json();
 							this.errorHandlers.forEach((handler) => handler(this.error));
 						}
 						this.pipeHandlers.forEach((handler) => {
@@ -169,10 +163,7 @@ var IRPCStream = class {
 				id: this.id,
 				name: this.name
 			}]);
-			this.error = {
-				code: ERROR_CODE.RESOLVE_ERROR,
-				message: error.message
-			};
+			this.error = ResolveError.failed(error).json();
 			this.status = IRPC_STATUS.ERROR;
 			this.pipeHandlers.forEach((handler) => {
 				handler({