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

package/dist/call.d.ts

@@ -12,7 +12,9 @@ declare const DEFAULT_RETRY_DELAY = 1000;
 declare class IRPCCall {
   transport: IRPCTransport;
   payload: IRPCPayload;
-  options: IRPCCallConfig;
+  options: IRPCCallConfig & {
+    seed?: () => IRPCData;
+  };
   /**
    * Unique identifier for this RPC call, generated using shortId().
    */
@@ -51,7 +53,9 @@ declare class IRPCCall {
    * @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, reader?: IRPCReader<IRPCData>);
+  constructor(transport: IRPCTransport, payload: IRPCPayload, options: IRPCCallConfig & {
+    seed?: () => IRPCData;
+  }, reader?: IRPCReader<IRPCData>);
   enqueue(packet: IRPCPacketStream<IRPCData>): void;
   /**
    * Resolves the RPC call with the provided value.

package/dist/call.js

@@ -1,5 +1,5 @@
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
-import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { CallError } from "./error.js";
 import { IRPCReader } from "./reader.js";
 import { IRPC_STORE } from "./store.js";
 import { uuid } from "@anchorlib/core";
@@ -60,16 +60,13 @@ var IRPCCall = class {
 				name: this.payload.name,
 				type: IRPC_PACKET_TYPE.CLOSE,
 				status: IRPC_STATUS.ERROR,
-				error: {
-					code: ERROR_CODE.TIMEOUT,
-					message: ERROR_MESSAGE[ERROR_CODE.TIMEOUT]
-				},
+				error: CallError.timeout().json(),
 				createdAt: Date.now()
 			});
 			clearTimeout(this.retryId);
-			this.reject(new Error(ERROR_MESSAGE[ERROR_CODE.TIMEOUT]), false);
+			this.reject(CallError.timeout(), false);
 		}, options.timeout);
-		this.reader = reader ?? new IRPCReader(uuid(), options?.init?.());
+		this.reader = reader ?? new IRPCReader(uuid(), options?.seed?.());
 		this.reader.onClose = () => this.close();
 		this.id = this.reader.id;
 	}
@@ -105,7 +102,7 @@ var IRPCCall = class {
 		if (maxRetries && retriable) {
 			if (reason) this.retryReasons.add(reason);
 			if (this.retries >= maxRetries) {
-				IRPC_STORE.error(/* @__PURE__ */ new Error(`${ERROR_MESSAGE[ERROR_CODE.CALL_MAX_RETRIES_REACHED]}: ${Array.from(this.retryReasons).map((r) => r.message).join(", ")}`), [{
+				IRPC_STORE.error(CallError.maxRetries(this.retryReasons), [{
 					id: this.id,
 					name: this.payload.name
 				}]);

package/dist/enum.d.ts

@@ -4,15 +4,6 @@ declare const IRPC_PACKET_TYPE: {
   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_STATUS: {
   readonly IDLE: "idle";
@@ -40,4 +31,4 @@ declare const IRPC_FILE_STATUS: {
   readonly ERROR: "error";
 };
 //#endregion
-export { IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE_EVENT };
+export { IRPC_BASE_CONTEXT, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE_EVENT };

package/dist/enum.js

@@ -3,16 +3,7 @@ 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"
+	ANSWER: "answer"
 };
 const IRPC_STATUS = {
 	IDLE: "idle",
@@ -41,4 +32,4 @@ const IRPC_FILE_STATUS = {
 };
 
 //#endregion
-export { IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE_EVENT };
+export { IRPC_BASE_CONTEXT, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE_EVENT };

package/dist/error.d.ts

@@ -1,61 +1,116 @@
+import { IRPCPacketError } from "./types.js";
+
 //#region src/error.d.ts
-declare const ERROR_CODE: {
-  UNKNOWN: string;
-  TIMEOUT: string;
-  NOT_FOUND: string;
-  NOT_SUPPORTED: string;
-  INVALID_TYPE: string;
-  INVALID_STATE: string;
-  INVALID_VALUE: string;
-  INVALID_INPUT: string;
-  INVALID_OUTPUT: string;
-  NOT_IMPLEMENTED: string;
-  INVALID_HANDLER: string;
-  INVALID_OPERATION: string;
-  INVALID_HOOK: string;
-  TRANSPORT_MISSING: string;
-  TRANSPORT_INVALID: string;
-  TRANSPORT_NOT_IMPLEMENTED: string;
-  STUB_MISSING: string;
-  STUB_INVALID: string;
-  STUB_NOT_IMPLEMENTED: string;
-  RESOLVER_MISSING: string;
-  RESOLVER_NOT_IMPLEMENTED: string;
-  RESOLVER_NOT_FOUND: string;
-  RESOLVER_NOT_SUPPORTED: string;
-  STREAM_ERROR: string;
-  HANDLER_ERROR: string;
-  RESOLVE_ERROR: string;
-  CALL_MAX_RETRIES_REACHED: string;
+declare const IRPC_ERROR_TYPE: {
+  readonly STUB: "stub";
+  readonly HOOK: "hook";
+  readonly CALL: "call";
+  readonly HANDLER: "handler";
+  readonly RESOLVE: "resolve";
+  readonly TRANSPORT: "transport";
 };
-type ErrorCode = (typeof ERROR_CODE)[keyof typeof ERROR_CODE];
-declare const ERROR_MESSAGE: {
-  [ERROR_CODE.UNKNOWN]: string;
-  [ERROR_CODE.TIMEOUT]: string;
-  [ERROR_CODE.NOT_FOUND]: string;
-  [ERROR_CODE.NOT_SUPPORTED]: string;
-  [ERROR_CODE.INVALID_TYPE]: string;
-  [ERROR_CODE.INVALID_STATE]: string;
-  [ERROR_CODE.INVALID_VALUE]: string;
-  [ERROR_CODE.INVALID_INPUT]: string;
-  [ERROR_CODE.INVALID_OUTPUT]: string;
-  [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;
-  [ERROR_CODE.STUB_INVALID]: string;
-  [ERROR_CODE.STREAM_ERROR]: string;
-  [ERROR_CODE.HANDLER_ERROR]: string;
-  [ERROR_CODE.RESOLVE_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;
+type IRPCErrorType = (typeof IRPC_ERROR_TYPE)[keyof typeof IRPC_ERROR_TYPE];
+declare const STUB_ERROR: {
+  readonly DUPLICATE: "duplicate";
+  readonly INVALID: "invalid";
+  readonly NOT_FOUND: "not_found";
+  readonly INVALID_NAME: "invalid_name";
+  readonly INVALID_VERSION: "invalid_version";
 };
+declare const HANDLER_ERROR: {
+  readonly INVALID: "invalid";
+  readonly MISSING: "missing";
+  readonly ERROR: "error";
+};
+declare const TRANSPORT_ERROR: {
+  readonly INVALID: "invalid";
+  readonly MISSING: "missing";
+  readonly NOT_IMPLEMENTED: "not_implemented";
+  readonly NOT_CONNECTED: "not_connected";
+  readonly CLOSED: "closed";
+  readonly INVALID_BODY: "invalid_body";
+  readonly STREAM_TERMINATED: "stream_terminated";
+  readonly ERROR: "error";
+};
+declare const RESOLVE_ERROR: {
+  readonly NOT_FOUND: "not_found";
+  readonly INVALID_INPUT: "invalid_input";
+  readonly INVALID_OUTPUT: "invalid_output";
+  readonly ERROR: "error";
+};
+declare const HOOK_ERROR: {
+  readonly INVALID: "invalid";
+  readonly ERROR: "error";
+};
+declare const CALL_ERROR: {
+  readonly TIMEOUT: "timeout";
+  readonly MAX_RETRIES: "max_retries";
+  readonly STREAM_ERROR: "stream_error";
+};
+/**
+ * Base error class for all IRPC errors.
+ *
+ * @property type - The domain category of the error (stub, handler, transport, etc.)
+ * @property code - A stable, machine-readable code for translation or programmatic matching.
+ */
+declare class IRPCError extends Error {
+  type: IRPCErrorType;
+  code: string;
+  cause?: Error | undefined;
+  constructor(type: IRPCErrorType, code: string, message: string, cause?: Error | undefined);
+  /** Serialize to the wire format used in IRPC packets. */
+  json(): IRPCPacketError;
+  /** Reconstruct an IRPCError from a wire packet error. */
+  static from(obj: IRPCPacketError): IRPCError;
+}
+/** Errors related to stub declaration, registration, and lookup. */
+declare class StubError extends IRPCError {
+  constructor(code: string, message: string, cause?: Error);
+  static duplicate(name: string): StubError;
+  static invalid(): StubError;
+  static notFound(): StubError;
+  static invalidName(name: string): StubError;
+  static invalidVersion(version: string): StubError;
+}
+/** Errors related to handler registration and execution. */
+declare class HandlerError extends IRPCError {
+  constructor(code: string, message: string, cause?: Error);
+  static invalid(): HandlerError;
+  static missing(name: string): HandlerError;
+  static failed(input: Error | string): HandlerError;
+}
+/** Errors related to the transport layer. */
+declare class TransportError extends IRPCError {
+  constructor(code: string, message: string, cause?: Error);
+  static missing(): TransportError;
+  static invalid(): TransportError;
+  static notImplemented(): TransportError;
+  static notConnected(name: string): TransportError;
+  static closed(name: string): TransportError;
+  static invalidBody(): TransportError;
+  static streamTerminated(): TransportError;
+  static failed(input: Error | string): TransportError;
+}
+/** Errors related to server-side request resolution. */
+declare class ResolveError extends IRPCError {
+  constructor(code: string, message: string, cause?: Error);
+  static notFound(name: string): ResolveError;
+  static invalidInput(input: Error | string): ResolveError;
+  static invalidOutput(input?: Error | string): ResolveError;
+  static failed(input: Error | string): ResolveError;
+}
+/** Errors related to hook registration and execution. */
+declare class HookError extends IRPCError {
+  constructor(code: string, message: string, cause?: Error);
+  static invalid(): HookError;
+  static failed(input: Error | string): HookError;
+}
+/** Errors related to call execution lifecycle. */
+declare class CallError extends IRPCError {
+  constructor(code: string, message: string, cause?: Error);
+  static timeout(): CallError;
+  static maxRetries(reasons: Set<Error>): CallError;
+  static streamError(input: Error | string): CallError;
+}
 //#endregion
-export { ERROR_CODE, ERROR_MESSAGE, ErrorCode };
+export { CALL_ERROR, CallError, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCError, IRPCErrorType, IRPC_ERROR_TYPE, RESOLVE_ERROR, ResolveError, STUB_ERROR, StubError, TRANSPORT_ERROR, TransportError };

package/dist/error.js

@@ -1,61 +1,212 @@
 //#region src/error.ts
-const ERROR_CODE = {
-	UNKNOWN: "unknown",
-	TIMEOUT: "timeout",
+const IRPC_ERROR_TYPE = {
+	STUB: "stub",
+	HOOK: "hook",
+	CALL: "call",
+	HANDLER: "handler",
+	RESOLVE: "resolve",
+	TRANSPORT: "transport"
+};
+const STUB_ERROR = {
+	DUPLICATE: "duplicate",
+	INVALID: "invalid",
 	NOT_FOUND: "not_found",
-	NOT_SUPPORTED: "not_supported",
-	INVALID_TYPE: "invalid_type",
-	INVALID_STATE: "invalid_state",
-	INVALID_VALUE: "invalid_value",
-	INVALID_INPUT: "invalid_argument",
-	INVALID_OUTPUT: "invalid_argument",
+	INVALID_NAME: "invalid_name",
+	INVALID_VERSION: "invalid_version"
+};
+const HANDLER_ERROR = {
+	INVALID: "invalid",
+	MISSING: "missing",
+	ERROR: "error"
+};
+const TRANSPORT_ERROR = {
+	INVALID: "invalid",
+	MISSING: "missing",
 	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",
-	STUB_MISSING: "stub_missing",
-	STUB_INVALID: "stub_invalid",
-	STUB_NOT_IMPLEMENTED: "stub_not_implemented",
-	RESOLVER_MISSING: "resolver_missing",
-	RESOLVER_NOT_IMPLEMENTED: "resolver_not_implemented",
-	RESOLVER_NOT_FOUND: "resolver_not_found",
-	RESOLVER_NOT_SUPPORTED: "resolver_not_supported",
-	STREAM_ERROR: "stream_error",
-	HANDLER_ERROR: "handler_error",
-	RESOLVE_ERROR: "resolve_error",
-	CALL_MAX_RETRIES_REACHED: "call_max_retries_reached"
-};
-const ERROR_MESSAGE = {
-	[ERROR_CODE.UNKNOWN]: "IRPC: Unknown error",
-	[ERROR_CODE.TIMEOUT]: "IRPC: Timeout error",
-	[ERROR_CODE.NOT_FOUND]: "IRPC: Not found error",
-	[ERROR_CODE.NOT_SUPPORTED]: "IRPC: Not supported error",
-	[ERROR_CODE.INVALID_TYPE]: "IRPC: Invalid type error",
-	[ERROR_CODE.INVALID_STATE]: "IRPC: Invalid state error",
-	[ERROR_CODE.INVALID_VALUE]: "IRPC: Invalid value error",
-	[ERROR_CODE.INVALID_INPUT]: "IRPC: Invalid input error",
-	[ERROR_CODE.INVALID_OUTPUT]: "IRPC: Invalid output error",
-	[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",
-	[ERROR_CODE.STUB_INVALID]: "IRPC: Stub invalid error",
-	[ERROR_CODE.STREAM_ERROR]: "IRPC: Stream error",
-	[ERROR_CODE.HANDLER_ERROR]: "IRPC: Handler error",
-	[ERROR_CODE.RESOLVE_ERROR]: "IRPC: Resolve 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_SUPPORTED]: "IRPC: Resolver not supported error",
-	[ERROR_CODE.CALL_MAX_RETRIES_REACHED]: "IRPC: Call max retries reached error"
+	NOT_CONNECTED: "not_connected",
+	CLOSED: "closed",
+	INVALID_BODY: "invalid_body",
+	STREAM_TERMINATED: "stream_terminated",
+	ERROR: "error"
+};
+const RESOLVE_ERROR = {
+	NOT_FOUND: "not_found",
+	INVALID_INPUT: "invalid_input",
+	INVALID_OUTPUT: "invalid_output",
+	ERROR: "error"
+};
+const HOOK_ERROR = {
+	INVALID: "invalid",
+	ERROR: "error"
+};
+const CALL_ERROR = {
+	TIMEOUT: "timeout",
+	MAX_RETRIES: "max_retries",
+	STREAM_ERROR: "stream_error"
+};
+function unwrap(input) {
+	if (input instanceof Error) return {
+		message: input.message,
+		cause: input
+	};
+	return { message: input };
+}
+/**
+* Base error class for all IRPC errors.
+*
+* @property type - The domain category of the error (stub, handler, transport, etc.)
+* @property code - A stable, machine-readable code for translation or programmatic matching.
+*/
+var IRPCError = class IRPCError extends Error {
+	constructor(type, code, message, cause) {
+		super(message);
+		this.type = type;
+		this.code = code;
+		this.cause = cause;
+	}
+	/** Serialize to the wire format used in IRPC packets. */
+	json() {
+		return {
+			type: this.type,
+			code: this.code,
+			message: this.message
+		};
+	}
+	/** Reconstruct an IRPCError from a wire packet error. */
+	static from(obj) {
+		const ErrorClass = IRPC_ERROR_CLASS[obj.type];
+		if (ErrorClass) return new ErrorClass(obj.code, obj.message);
+		return new IRPCError(obj.type, obj.code, obj.message);
+	}
+};
+/** Errors related to stub declaration, registration, and lookup. */
+var StubError = class StubError extends IRPCError {
+	constructor(code, message, cause) {
+		super(IRPC_ERROR_TYPE.STUB, code, message, cause);
+	}
+	static duplicate(name) {
+		return new StubError(STUB_ERROR.DUPLICATE, `IRPC "${name}" already exists.`);
+	}
+	static invalid() {
+		return new StubError(STUB_ERROR.INVALID, "Invalid stub.");
+	}
+	static notFound() {
+		return new StubError(STUB_ERROR.NOT_FOUND, "No spec found for stub.");
+	}
+	static invalidName(name) {
+		return new StubError(STUB_ERROR.INVALID_NAME, `Invalid name: ${name}`);
+	}
+	static invalidVersion(version) {
+		return new StubError(STUB_ERROR.INVALID_VERSION, `Invalid version: ${version}`);
+	}
+};
+/** Errors related to handler registration and execution. */
+var HandlerError = class HandlerError extends IRPCError {
+	constructor(code, message, cause) {
+		super(IRPC_ERROR_TYPE.HANDLER, code, message, cause);
+	}
+	static invalid() {
+		return new HandlerError(HANDLER_ERROR.INVALID, "Handler must be a function.");
+	}
+	static missing(name) {
+		return new HandlerError(HANDLER_ERROR.MISSING, `IRPC "${name}" has no implementation.`);
+	}
+	static failed(input) {
+		const { message, cause } = unwrap(input);
+		return new HandlerError(HANDLER_ERROR.ERROR, message, cause);
+	}
+};
+/** Errors related to the transport layer. */
+var TransportError = class TransportError extends IRPCError {
+	constructor(code, message, cause) {
+		super(IRPC_ERROR_TYPE.TRANSPORT, code, message, cause);
+	}
+	static missing() {
+		return new TransportError(TRANSPORT_ERROR.MISSING, "No transport configured.");
+	}
+	static invalid() {
+		return new TransportError(TRANSPORT_ERROR.INVALID, "Invalid transport.");
+	}
+	static notImplemented() {
+		return new TransportError(TRANSPORT_ERROR.NOT_IMPLEMENTED, "Transport dispatch not implemented.");
+	}
+	static notConnected(name) {
+		return new TransportError(TRANSPORT_ERROR.NOT_CONNECTED, `${name} is not connected.`);
+	}
+	static closed(name) {
+		return new TransportError(TRANSPORT_ERROR.CLOSED, `${name} connection closed.`);
+	}
+	static invalidBody() {
+		return new TransportError(TRANSPORT_ERROR.INVALID_BODY, "Invalid response body.");
+	}
+	static streamTerminated() {
+		return new TransportError(TRANSPORT_ERROR.STREAM_TERMINATED, "Response stream terminated.");
+	}
+	static failed(input) {
+		const { message, cause } = unwrap(input);
+		return new TransportError(TRANSPORT_ERROR.ERROR, message, cause);
+	}
+};
+/** Errors related to server-side request resolution. */
+var ResolveError = class ResolveError extends IRPCError {
+	constructor(code, message, cause) {
+		super(IRPC_ERROR_TYPE.RESOLVE, code, message, cause);
+	}
+	static notFound(name) {
+		return new ResolveError(RESOLVE_ERROR.NOT_FOUND, `IRPC "${name}" does not exist.`);
+	}
+	static invalidInput(input) {
+		const { message, cause } = unwrap(input);
+		return new ResolveError(RESOLVE_ERROR.INVALID_INPUT, message, cause);
+	}
+	static invalidOutput(input) {
+		if (!input) return new ResolveError(RESOLVE_ERROR.INVALID_OUTPUT, "Invalid output.");
+		const { message, cause } = unwrap(input);
+		return new ResolveError(RESOLVE_ERROR.INVALID_OUTPUT, message, cause);
+	}
+	static failed(input) {
+		const { message, cause } = unwrap(input);
+		return new ResolveError(RESOLVE_ERROR.ERROR, message, cause);
+	}
+};
+/** Errors related to hook registration and execution. */
+var HookError = class HookError extends IRPCError {
+	constructor(code, message, cause) {
+		super(IRPC_ERROR_TYPE.HOOK, code, message, cause);
+	}
+	static invalid() {
+		return new HookError(HOOK_ERROR.INVALID, "Hook must be a function.");
+	}
+	static failed(input) {
+		const { message, cause } = unwrap(input);
+		return new HookError(HOOK_ERROR.ERROR, message, cause);
+	}
+};
+/** Errors related to call execution lifecycle. */
+var CallError = class CallError extends IRPCError {
+	constructor(code, message, cause) {
+		super(IRPC_ERROR_TYPE.CALL, code, message, cause);
+	}
+	static timeout() {
+		return new CallError(CALL_ERROR.TIMEOUT, "Call timed out.");
+	}
+	static maxRetries(reasons) {
+		const detail = Array.from(reasons).map((r) => r.message).join(", ");
+		return new CallError(CALL_ERROR.MAX_RETRIES, `Max retries reached: ${detail}`);
+	}
+	static streamError(input) {
+		const { message, cause } = unwrap(input);
+		return new CallError(CALL_ERROR.STREAM_ERROR, message, cause);
+	}
+};
+const IRPC_ERROR_CLASS = {
+	[IRPC_ERROR_TYPE.STUB]: StubError,
+	[IRPC_ERROR_TYPE.HANDLER]: HandlerError,
+	[IRPC_ERROR_TYPE.TRANSPORT]: TransportError,
+	[IRPC_ERROR_TYPE.RESOLVE]: ResolveError,
+	[IRPC_ERROR_TYPE.HOOK]: HookError,
+	[IRPC_ERROR_TYPE.CALL]: CallError
 };
 
 //#endregion
-export { ERROR_CODE, ERROR_MESSAGE };
+export { CALL_ERROR, CallError, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCError, IRPC_ERROR_TYPE, RESOLVE_ERROR, ResolveError, STUB_ERROR, StubError, TRANSPORT_ERROR, TransportError };

package/dist/index.d.ts

@@ -1,19 +1,19 @@
 import { IRPCCacheEntry, IRPCCacher } from "./cache.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 { IRPC_BASE_CONTEXT, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE_EVENT } from "./enum.js";
 import { IRPCFile, IRPCFileMeta, IRPCFilePipe, IRPCFileState, IRPCFileStatus, IRPCFileStream, IRPCFileUnpipe } from "./file.js";
 import { IRPCFilePointer, IRPCFileQueue, IRPCPacketJson, IRPCPacketQueues, IRPC_FILE_IDENTIFIER, PacketStream, decode, encode, isFilePointer } from "./packet.js";
 import { IRPCHookArgs, IRPCPackage, IRPCSpecHook, createPackage, intercept } from "./module.js";
 import { IRPCTransport } from "./transport.js";
-import { IRPCArraySchema, IRPCBaseContext, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCCredentials, IRPCCredentialsFactory, 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, IRPCRequests, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStreamInit, IRPCStub, IRPCStubStore, StreamCleanup, StreamConstructor, TransportConfig } from "./types.js";
+import { IRPCArraySchema, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCCredentials, IRPCCredentialsFactory, IRPCData, IRPCDataSchema, IRPCDeclareInit, IRPCDefined, IRPCFunction, IRPCHandler, IRPCInferInit, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketError, IRPCPacketEvent, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCRequest, IRPCRequests, 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, createContextStore, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext } from "./context.js";
 import { createCredentials, credential, getCredentials } from "./credential.js";
+import { CALL_ERROR, CallError, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCError, IRPCErrorType, IRPC_ERROR_TYPE, RESOLVE_ERROR, ResolveError, STUB_ERROR, StubError, TRANSPORT_ERROR, TransportError } from "./error.js";
 import { IRPCResolver } from "./resolver.js";
 import { IRPCHook, IRPCRouter } from "./router.js";
 import { IRPCStream } from "./stream.js";
 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, IRPCCredentials, IRPCCredentialsFactory, 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, IRPCRequests, 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, createContextStore, createCredentials, createPackage, credential, decode, encode, getAbortController, getAbortSignal, getContext, getCredentials, intercept, isFilePointer, plan, setContext, setContextProvider, stream, withContext };
+export { CALL_ERROR, CallError, DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCArraySchema, IRPCCacheEntry, IRPCCacher, IRPCCall, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCCredentials, IRPCCredentialsFactory, IRPCData, IRPCDataSchema, IRPCDeclareInit, IRPCDefined, IRPCError, IRPCErrorType, IRPCFile, IRPCFileMeta, IRPCFilePipe, IRPCFilePointer, IRPCFileQueue, IRPCFileState, IRPCFileStatus, IRPCFileStream, IRPCFileUnpipe, IRPCFunction, IRPCHandler, IRPCHook, IRPCHookArgs, IRPCInferInit, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackage, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketError, IRPCPacketEvent, IRPCPacketJson, IRPCPacketQueues, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCReader, IRPCRequest, IRPCRequests, IRPCResolver, IRPCResponse, IRPCRouter, IRPCSchema, IRPCSpec, IRPCSpecHook, IRPCSpecStore, IRPCStatus, IRPCStore, IRPCStoreEvent, IRPCStoreSubscriber, IRPCStream, IRPCStreamInit, IRPCStub, IRPCStubStore, IRPCTransport, IRPC_BASE_CONTEXT, IRPC_ERROR_TYPE, IRPC_FILE_IDENTIFIER, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE, IRPC_STORE_EVENT, PacketStream, RESOLVE_ERROR, RemoteState, ResolveError, STUB_ERROR, StreamCleanup, StreamConstructor, StubError, TRANSPORT_ERROR, TransportConfig, TransportError, createContext, createContextStore, createCredentials, createPackage, credential, decode, encode, getAbortController, getAbortSignal, getContext, getCredentials, intercept, isFilePointer, plan, setContext, setContextProvider, stream, withContext };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { IRPCCacher } from "./cache.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 { IRPC_BASE_CONTEXT, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE_EVENT } from "./enum.js";
+import { CALL_ERROR, CallError, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCError, IRPC_ERROR_TYPE, RESOLVE_ERROR, ResolveError, STUB_ERROR, StubError, TRANSPORT_ERROR, TransportError } from "./error.js";
 import { createContext, createContextStore, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext } from "./context.js";
 import { RemoteState, stream } from "./state.js";
 import { IRPCReader } from "./reader.js";
@@ -16,4 +16,4 @@ 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, 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, createContextStore, createCredentials, createPackage, credential, decode, encode, getAbortController, getAbortSignal, getContext, getCredentials, intercept, isFilePointer, plan, setContext, setContextProvider, stream, withContext };
+export { CALL_ERROR, CallError, DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCCacher, IRPCCall, IRPCError, IRPCFile, IRPCFileStream, IRPCPackage, IRPCReader, IRPCResolver, IRPCRouter, IRPCStore, IRPCStream, IRPCTransport, IRPC_BASE_CONTEXT, IRPC_ERROR_TYPE, IRPC_FILE_IDENTIFIER, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE, IRPC_STORE_EVENT, RESOLVE_ERROR, RemoteState, ResolveError, STUB_ERROR, StubError, TRANSPORT_ERROR, TransportError, createContext, createContextStore, createCredentials, createPackage, credential, decode, encode, getAbortController, getAbortSignal, getContext, getCredentials, intercept, isFilePointer, plan, setContext, setContextProvider, stream, withContext };

package/dist/module.js

@@ -1,6 +1,6 @@
 import { IRPCCacher } from "./cache.js";
 import { IRPC_STATUS } from "./enum.js";
-import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { HandlerError, ResolveError, StubError, TransportError } from "./error.js";
 import { getAbortSignal } from "./context.js";
 import { RemoteState } from "./state.js";
 import { IRPCReader } from "./reader.js";
@@ -79,15 +79,16 @@ var IRPCPackage = class {
 	*/
 	declare(options) {
 		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 +101,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 +126,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,13 +150,13 @@ 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
 			};
@@ -163,8 +164,7 @@ var IRPCPackage = class {
 				timeout,
 				maxRetries,
 				retryDelay,
-				retryMode,
-				init
+				retryMode
 			};
 			const hooks = this.hooks.get(spec);
 			if (hooks) hooks.forEach((hook) => hook({
@@ -192,8 +192,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,10 +204,10 @@ 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;
 	}
@@ -220,7 +220,7 @@ var IRPCPackage = class {
 	*/
 	hook(stub, handler) {
 		if (!this.stubs.has(stub)) {
-			const error = new Error(ERROR_MESSAGE[ERROR_CODE.NOT_FOUND]);
+			const error = StubError.notFound();
 			IRPC_STORE.error(error);
 			return this;
 		}
@@ -236,7 +236,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 +247,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 +269,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,4 +1,5 @@
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
+import { IRPCError } from "./error.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.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";
 
 //#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 { IRPC_BASE_CONTEXT, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
-import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { HookError } 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 { IRPC_STATUS } from "./enum.js";
-import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { IRPCError, IRPC_ERROR_TYPE } 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/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 { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
-import { ERROR_CODE } from "./error.js";
+import { CallError, HandlerError, ResolveError } 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({

package/dist/transport.js

@@ -1,5 +1,5 @@
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
-import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { TransportError } from "./error.js";
 import { IRPCReader } from "./reader.js";
 import { IRPC_STORE } from "./store.js";
 import { IRPCCall } from "./call.js";
@@ -119,10 +119,7 @@ var IRPCTransport = class {
 				name: call.payload.name,
 				type: IRPC_PACKET_TYPE.CLOSE,
 				status: IRPC_STATUS.ERROR,
-				error: {
-					code: ERROR_CODE.TRANSPORT_NOT_IMPLEMENTED,
-					message: ERROR_MESSAGE[ERROR_CODE.TRANSPORT_NOT_IMPLEMENTED]
-				},
+				error: TransportError.notImplemented().json(),
 				createdAt: Date.now()
 			});
 		});

package/dist/types.d.ts

@@ -1,5 +1,4 @@
-import { IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
-import { ErrorCode } from "./error.js";
+import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { IRPCFile } from "./file.js";
 import { IRPCFilePointer } from "./packet.js";
 import { IRPCTransport } from "./transport.js";
@@ -21,9 +20,7 @@ type IRPCStubStore = WeakMap<IRPCHandler, IRPCSpec<IRPCInputs, IRPCOutput>>;
  */
 type IRPCSpecStore = Map<string, IRPCSpec<IRPCInputs, IRPCOutput>>;
 type IRPCStatus = (typeof IRPC_STATUS)[keyof typeof IRPC_STATUS];
-type IRPCDataType = (typeof IRPC_DATA_TYPE)[keyof typeof IRPC_DATA_TYPE];
 type IRPCPacketType = (typeof IRPC_PACKET_TYPE)[keyof typeof IRPC_PACKET_TYPE];
-type IRPCBaseContext = (typeof IRPC_BASE_CONTEXT)[keyof typeof IRPC_BASE_CONTEXT];
 type IRPCPacketBase = {
   id: string;
   name: string;
@@ -37,13 +34,13 @@ type IRPCPacketCall = IRPCPacketBase & {
 };
 type IRPCPacketAnswer<T extends IRPCData> = IRPCPacketBase & {
   data?: T;
-  error?: IRPCError;
+  error?: IRPCPacketError;
 };
 type IRPCPacketEvent = IRPCPacketBase & {
   data: StateChange;
 };
 type IRPCPacketClose = IRPCPacketBase & {
-  error?: IRPCError;
+  error?: IRPCPacketError;
 };
 type IRPCPacketStream<T extends IRPCData> = IRPCPacketAnswer<T> | IRPCPacketEvent | IRPCPacketClose;
 interface IRPCReadable<T> {
@@ -118,6 +115,11 @@ type IRPCObject = {
  * This is a recursive type that allows nested structures.
  */
 type IRPCData = IRPCPrimitive | IRPCObject | IRPCFile | IRPCData[];
+/**
+ * Represents all possible defined data types in IRPC, including primitives, objects, and arrays.
+ * This is a recursive type that allows nested structures.
+ */
+type IRPCDefined = string | number | boolean | IRPCObject | IRPCFile | IRPCDefined[];
 /**
  * Union type of all primitive Zod schema types used for validation.
  */
@@ -206,9 +208,12 @@ type IRPCInit<R$1, I extends IRPCInputs, O$1 extends IRPCOutput> = {
    * This can help reduce the number of actual function executions.
    */
   coalesce?: boolean;
-  /** Optional initialization function to seed the data */
-  init?: () => R$1;
-} & IRPCCallConfig;
+} & IRPCCallConfig & IRPCInferInit<R$1>;
+type IRPCInferInit<R$1> = R$1 extends IRPCDefined ? {
+  seed: () => R$1;
+} : {
+  seed?: () => R$1;
+};
 /**
  * Configuration options for initializing an RPC stream function.
  * Contains metadata and constraints for the RPC stream function.
@@ -228,7 +233,7 @@ type IRPCStreamInit<I extends IRPCInputs, O$1 extends IRPCOutput, R$1> = IRPCIni
  * @template I - Tuple of input validation schemas
  * @template O - Output validation schema
  */
-type IRPCDeclareInit<F, I extends IRPCInputs, O$1 extends IRPCOutput> = F extends ((...args: IRPCData[]) => infer R) ? R extends RemoteState<infer S> ? S extends IRPCData ? IRPCStreamInit<I, O$1, S> : IRPCInit<IRPCData, IRPCInputs, IRPCOutput> : R extends Promise<infer D> ? D extends IRPCData ? IRPCInit<D, I, O$1> : IRPCInit<IRPCData, IRPCInputs, IRPCOutput> : R extends IRPCData ? IRPCInit<R, I, O$1> : IRPCInit<IRPCData, IRPCInputs, IRPCOutput> : IRPCInit<IRPCData, IRPCInputs, IRPCOutput>;
+type IRPCDeclareInit<F, I extends IRPCInputs, O$1 extends IRPCOutput> = F extends ((...args: infer _A) => infer R) ? R extends RemoteState<infer S> ? S extends IRPCData ? IRPCStreamInit<I, O$1, S> : IRPCInit<S, IRPCInputs, IRPCOutput> : R extends Promise<infer D> ? D extends IRPCData ? IRPCInit<D, I, O$1> : IRPCInit<D, IRPCInputs, IRPCOutput> : R extends IRPCData ? IRPCInit<R, I, O$1> : IRPCInit<R, IRPCInputs, IRPCOutput> : IRPCInit<IRPCData, IRPCInputs, IRPCOutput>;
 /**
  * Complete specification for an RPC function including its implementation.
  * Extends IRPCInit with the actual handler function.
@@ -243,8 +248,6 @@ type IRPCSpec<I extends IRPCInputs, O$1 extends IRPCOutput> = IRPCInit<IRPCData,
   stream?: boolean;
   /** The actual handler function that implements the RPC */
   handler: IRPCHandler;
-  /** Optional initialization function for a stream RPC */
-  init?: () => unknown;
 };
 /**
  * Represents an incoming RPC request.
@@ -264,8 +267,9 @@ type IRPCRequests = {
   calls: IRPCRequest[];
   credentials?: IRPCCredentials;
 };
-type IRPCError = {
-  code: ErrorCode;
+type IRPCPacketError = {
+  type: string;
+  code: string;
   message: string;
 };
 /**
@@ -277,7 +281,7 @@ type IRPCResponse = {
   /** Name of the RPC function that was called */
   name: string;
   /** Error message if the call failed */
-  error?: IRPCError;
+  error?: IRPCPacketError;
   /** Result of the RPC call if successful */
   result?: unknown;
 };
@@ -310,8 +314,6 @@ type IRPCCallConfig = {
   retryMode?: 'linear' | 'exponential';
   /** Base delay between retries in milliseconds */
   retryDelay?: number;
-  /** Optional initialization function for a stream RPC */
-  init?: () => unknown;
 };
 /**
  * Configuration for transport layer, extending call configuration with debounce settings.
@@ -333,4 +335,4 @@ type StreamCleanup = () => void;
  */
 type StreamConstructor<T> = (state: IRPCReadable<T>, resolve: (value?: T) => void, reject: (error: Error) => void) => StreamCleanup | void | Promise<StreamCleanup | void>;
 //#endregion
-export { IRPCArraySchema, IRPCBaseContext, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCCredentials, IRPCCredentialsFactory, 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, IRPCRequests, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStreamInit, IRPCStub, IRPCStubStore, StreamCleanup, StreamConstructor, TransportConfig };
+export { IRPCArraySchema, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCCredentials, IRPCCredentialsFactory, IRPCData, IRPCDataSchema, IRPCDeclareInit, IRPCDefined, IRPCFunction, IRPCHandler, IRPCInferInit, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketError, IRPCPacketEvent, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCRequest, IRPCRequests, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStreamInit, IRPCStub, IRPCStubStore, StreamCleanup, StreamConstructor, TransportConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@irpclib/irpc",
-  "version": "1.0.0-beta.24",
+  "version": "1.0.0-beta.25",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
   "exports": {
@@ -14,7 +14,9 @@
       "import": "./dist/server/index.js"
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "directories": {
     "dist": "./dist"
   },
@@ -50,6 +52,6 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@anchorlib/core": "^1.0.0-beta.24"
+    "@anchorlib/core": "^1.0.0-beta.25"
   }
-}
+}