@irpclib/irpc 1.0.0-beta.23 → 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/context.d.ts

@@ -1,5 +1,5 @@
 import { IRPCContext, IRPCContextProvider } from "./types.js";
-import { AsyncStore, getContext, setContext } from "@anchorlib/core";
+import { AsyncStore, createContext, getContext, setContext } from "@anchorlib/core";
 
 //#region src/context.d.ts
 
@@ -23,8 +23,8 @@ declare function withContext<R>(ctx: IRPCContext<string | symbol, unknown>, fn:
  * @param init - Optional initial key-value pairs for the context
  * @returns A new Map instance representing the context
  */
-declare function createContext<K extends string | symbol, V>(init?: [K, V][]): AsyncStore;
+declare function createContextStore<K extends string | symbol, V>(init?: [K, V][]): AsyncStore;
 declare function getAbortSignal(): AbortSignal | undefined;
 declare function getAbortController(): AbortController | undefined;
 //#endregion
-export { createContext, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext };
+export { createContext, createContextStore, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext };

package/dist/context.js

@@ -1,5 +1,5 @@
 import { IRPC_BASE_CONTEXT } from "./enum.js";
-import { AsyncStore, getContext, setAsyncScope, setContext, withIsolation } from "@anchorlib/core";
+import { AsyncStore, createContext, getContext, setAsyncScope, setContext, withIsolation } from "@anchorlib/core";
 
 //#region src/context.ts
 /**
@@ -26,7 +26,7 @@ function withContext(ctx, fn) {
 * @param init - Optional initial key-value pairs for the context
 * @returns A new Map instance representing the context
 */
-function createContext(init) {
+function createContextStore(init) {
 	return new AsyncStore(init);
 }
 function getAbortSignal() {
@@ -37,4 +37,4 @@ function getAbortController() {
 }
 
 //#endregion
-export { createContext, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext };
+export { createContext, createContextStore, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext };

package/dist/credential.d.ts

@@ -0,0 +1,9 @@
+import { IRPCCredentials } from "./types.js";
+import { AsyncStore } from "@anchorlib/core";
+
+//#region src/credential.d.ts
+declare function createCredentials(seeds: IRPCCredentials): AsyncStore;
+declare function getCredentials(): AsyncStore;
+declare function credential<V>(key: string): V | undefined;
+//#endregion
+export { createCredentials, credential, getCredentials };

package/dist/credential.js

@@ -0,0 +1,16 @@
+import { IRPC_BASE_CONTEXT } from "./enum.js";
+import { AsyncStore, getContext } from "@anchorlib/core";
+
+//#region src/credential.ts
+function createCredentials(seeds) {
+	return new AsyncStore(seeds);
+}
+function getCredentials() {
+	return getContext(IRPC_BASE_CONTEXT.CREDENTIALS);
+}
+function credential(key) {
+	return getCredentials()?.get(key);
+}
+
+//#endregion
+export { createCredentials, credential, getCredentials };

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";
@@ -31,6 +22,7 @@ declare const IRPC_STORE_EVENT: {
 declare const IRPC_BASE_CONTEXT: {
   readonly ABORT_SIGNAL: symbol;
   readonly ABORT_CONTROLLER: symbol;
+  readonly CREDENTIALS: symbol;
 };
 declare const IRPC_FILE_STATUS: {
   readonly IDLE: "idle";
@@ -39,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",
@@ -30,7 +21,8 @@ const IRPC_STORE_EVENT = {
 };
 const IRPC_BASE_CONTEXT = {
 	ABORT_SIGNAL: Symbol("abort-signal"),
-	ABORT_CONTROLLER: Symbol("abort-controller")
+	ABORT_CONTROLLER: Symbol("abort-controller"),
+	CREDENTIALS: Symbol("credentials")
 };
 const IRPC_FILE_STATUS = {
 	IDLE: "idle",
@@ -40,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,57 +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;
-  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.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,57 +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",
-	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.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,18 +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, IRPCData, IRPCDataSchema, IRPCDataType, IRPCDeclareInit, IRPCError, IRPCFunction, IRPCHandler, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketEvent, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStreamInit, IRPCStub, IRPCStubStore, StreamCleanup, StreamConstructor, TransportConfig } from "./types.js";
+import { 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, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext } from "./context.js";
-import { IRPCHookArgs, IRPCPackage, IRPCSpecHook, createPackage, intercept } from "./module.js";
-import { IRPCFilePointer, IRPCFileQueue, IRPCPacketJson, IRPCPacketQueues, IRPC_FILE_IDENTIFIER, PacketStream, decode, encode, isFilePointer } from "./packet.js";
+import { 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, IRPCData, IRPCDataSchema, IRPCDataType, IRPCDeclareInit, IRPCError, IRPCFile, IRPCFileMeta, IRPCFilePipe, IRPCFilePointer, IRPCFileQueue, IRPCFileState, IRPCFileStatus, IRPCFileStream, IRPCFileUnpipe, IRPCFunction, IRPCHandler, IRPCHook, IRPCHookArgs, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackage, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketEvent, IRPCPacketJson, IRPCPacketQueues, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCReader, IRPCRequest, IRPCResolver, IRPCResponse, IRPCRouter, IRPCSchema, IRPCSpec, IRPCSpecHook, IRPCSpecStore, IRPCStatus, IRPCStore, IRPCStoreEvent, IRPCStoreSubscriber, IRPCStream, IRPCStreamInit, IRPCStub, IRPCStubStore, IRPCTransport, IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_FILE_IDENTIFIER, IRPC_FILE_STATUS, IRPC_PACKET_TYPE, IRPC_STATUS, IRPC_STORE, IRPC_STORE_EVENT, PacketStream, RemoteState, StreamCleanup, StreamConstructor, TransportConfig, createContext, createPackage, decode, encode, getAbortController, getAbortSignal, getContext, intercept, isFilePointer, plan, setContext, setContextProvider, stream, withContext };
+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 };