@irpclib/irpc 1.0.0-beta.24 → 1.0.0

package/dist/error.js

@@ -1,61 +1,230 @@
 //#region src/error.ts
-const ERROR_CODE = {
-	UNKNOWN: "unknown",
-	TIMEOUT: "timeout",
+const IRPC_ERROR_TYPE = {
+	STUB: "stub",
+	HOOK: "hook",
+	CALL: "call",
+	CRUD: "crud",
+	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"
+};
+const CRUD_ERROR = {
+	NOT_FOUND: "not_found",
+	NOT_IMPLEMENTED: "not_implemented"
+};
+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);
+	}
+};
+/** Errors related to CRUD adapter operations. */
+var CrudError = class CrudError extends IRPCError {
+	constructor(code, message, cause) {
+		super(IRPC_ERROR_TYPE.CRUD, code, message, cause);
+	}
+	static notFound() {
+		return new CrudError(CRUD_ERROR.NOT_FOUND, "Unknown CRUD instance — was it created with pkg.crud()?");
+	}
+	static notImplemented(method) {
+		return new CrudError(CRUD_ERROR.NOT_IMPLEMENTED, `CRUD method "${method}" not implemented.`);
+	}
+};
+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,
+	[IRPC_ERROR_TYPE.CRUD]: CrudError
 };
 
 //#endregion
-export { ERROR_CODE, ERROR_MESSAGE };
+export { CALL_ERROR, CRUD_ERROR, CallError, CrudError, 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,20 @@
-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 { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, IRPCCall } from "./call.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, IRPCCrudField, IRPCCrudMeta, IRPCCrudMethod, IRPCCrudOptions, IRPCCrudStubs, IRPCData, IRPCDataSchema, IRPCDeclareConfig, IRPCDeclareInit, IRPCDefined, IRPCDriver, IRPCEntityId, 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, IRPCReturnOf, 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 { IRPCHookArgs, IRPCPackage, IRPCSpecHook, createPackage, intercept } from "./module.js";
+import { IRPCAdapter } from "./adapter.js";
+import { IRPCCacheEntry, IRPCCacher } from "./cache.js";
 import { createContext, createContextStore, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext } from "./context.js";
 import { createCredentials, credential, getCredentials } from "./credential.js";
+import { CALL_ERROR, CRUD_ERROR, CallError, CrudError, 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, CRUD_ERROR, CallError, CrudError, DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCAdapter, IRPCArraySchema, IRPCCacheEntry, IRPCCacher, IRPCCall, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCCredentials, IRPCCredentialsFactory, IRPCCrudField, IRPCCrudMeta, IRPCCrudMethod, IRPCCrudOptions, IRPCCrudStubs, IRPCData, IRPCDataSchema, IRPCDeclareConfig, IRPCDeclareInit, IRPCDefined, IRPCDriver, IRPCEntityId, 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, IRPCReturnOf, 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,7 @@
+import { CALL_ERROR, CRUD_ERROR, CallError, CrudError, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCError, IRPC_ERROR_TYPE, RESOLVE_ERROR, ResolveError, STUB_ERROR, StubError, TRANSPORT_ERROR, TransportError } from "./error.js";
+import { IRPCAdapter } from "./adapter.js";
 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 { createContext, createContextStore, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext } from "./context.js";
 import { RemoteState, stream } from "./state.js";
 import { IRPCReader } from "./reader.js";
@@ -14,6 +15,7 @@ import { createCredentials, credential, getCredentials } from "./credential.js";
 import { IRPCFile, IRPCFileStream } from "./file.js";
 import { IRPC_FILE_IDENTIFIER, decode, encode, isFilePointer } from "./packet.js";
 import { IRPCResolver } from "./resolver.js";
+import { IRPCDriver } from "./types.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, CRUD_ERROR, CallError, CrudError, DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCAdapter, IRPCCacher, IRPCCall, IRPCDriver, 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.d.ts

@@ -1,5 +1,5 @@
 import { IRPCTransport } from "./transport.js";
-import { IRPCData, IRPCDeclareInit, IRPCFunction, IRPCHandler, IRPCInputs, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCRequest, IRPCSpec, IRPCStub } from "./types.js";
+import { IRPCCrudMethod, IRPCCrudOptions, IRPCCrudStubs, IRPCData, IRPCDeclareConfig, IRPCDeclareInit, IRPCFunction, IRPCHandler, IRPCInferInit, IRPCInputs, IRPCObject, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCRequest, IRPCReturnOf, IRPCSpec, IRPCStub } from "./types.js";
 import { RemoteState } from "./state.js";
 import { IRPCReader } from "./reader.js";
 
@@ -17,7 +17,7 @@ type IRPCSpecHook<F$1> = (req: IRPCHookArgs<F$1>) => void | Promise<void>;
  * and their corresponding stubs. It manages the configuration, transport, and execution
  * of remote procedure calls.
  */
-declare class IRPCPackage {
+declare class IRPCPackage<K extends string = 'id'> {
   /**
    * A map storing all IRPC specifications by their names
    */
@@ -54,12 +54,47 @@ declare class IRPCPackage {
    */
   constructor(config?: Partial<IRPCPackageConfig>);
   /**
-   * 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
+   * Declares a new IRPC specification and returns a callable stub.
+   *
+   * @param name - The unique name for the IRPC specification.
+   * @param seed - Factory function returning the initial data value.
+   * @param config - Optional configuration (description, schema, caching, etc).
+   * @returns A stub function that can be used to call the IRPC.
+   * @throws Error if an IRPC with the same name already exists.
+   */
+  declare<F, I extends IRPCInputs = IRPCInputs, O extends IRPCOutput = IRPCOutput>(name: string, seed: () => IRPCReturnOf<F>, config?: IRPCDeclareConfig<I, O>): IRPCFunction<F>;
+  /**
+   * Declares a new IRPC specification and returns a callable stub.
+   *
+   * @param name - The unique name for the IRPC specification.
+   * @param config - Configuration object including seed and optional fields.
+   * @returns A stub function that can be used to call the IRPC.
+   * @throws Error if an IRPC with the same name already exists.
+   */
+  declare<F, I extends IRPCInputs = IRPCInputs, O extends IRPCOutput = IRPCOutput>(name: string, config: IRPCDeclareConfig<I, O> & IRPCInferInit<IRPCReturnOf<F>>): IRPCFunction<F>;
+  /**
+   * Declares a new IRPC specification and returns a callable stub.
+   *
+   * @param options - The initialization object containing name, seed, and configuration.
+   * @returns A stub function that can be used to call the IRPC.
+   * @throws Error if an IRPC with the same name already exists.
    */
   declare<F, I extends IRPCInputs = IRPCInputs, O extends IRPCOutput = IRPCOutput>(options: IRPCDeclareInit<F, I, O>): IRPCFunction<F>;
+  /**
+   * 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<T extends IRPCObject, I extends IRPCObject = T, U extends IRPCObject = T, CK extends string = K>(name: string, seed: () => T, options?: IRPCCrudOptions): IRPCCrudStubs<T, CK, I, U>;
+  /**
+   * 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<S extends object, E extends IRPCCrudMethod>(stubs: S, keys: E[]): Omit<S, E>;
   /**
    * Resolves and executes an IRPC call based on a request object
    * @param req - The request containing the IRPC name and arguments
@@ -76,13 +111,17 @@ declare class IRPCPackage {
    */
   construct<F, A extends unknown[], R extends IRPCData>(stub: IRPCStub<F, A, R>, handler: F): this;
   /**
-   * Registers a hook function for a specific stub function
-   * @param stub - The stub function created by declare()
-   * @param handler - The hook function to register
-   * @returns This IRPCPackage instance for chaining
-   * @throws Error if the stub is invalid or if no IRPC exists for the stub
+   * Registers a hook for a specific stub.
+   * @param stub - The stub function created by declare().
+   * @param handler - The hook function to register.
    */
   hook<F extends IRPCHandler>(stub: F, handler: IRPCSpecHook<F>): this;
+  /**
+   * Registers a hook for all stubs in a group (e.g., CRUD).
+   * @param stubs - An object whose values are stub functions.
+   * @param handler - The hook function to register.
+   */
+  hook(stubs: Record<string, IRPCHandler>, handler: IRPCSpecHook<IRPCHandler>): this;
   /**
    * Resolves and executes all registered hooks for a given request
    * @param req - The request containing the IRPC name and arguments
@@ -122,7 +161,9 @@ declare class IRPCPackage {
  * @param config - Optional partial configuration for the package
  * @returns A new IRPCPackage instance
  */
-declare function createPackage(config?: Partial<IRPCPackageConfig>): IRPCPackage;
+declare function createPackage<K extends string = 'id'>(config?: Partial<IRPCPackageConfig> & {
+  key?: K;
+}): IRPCPackage<K>;
 /**
  * Intercepts local function call to get an instant response without remote execution.
  *