@irpclib/irpc 1.0.0-beta.25 → 1.1.0

package/dist/adapter.d.ts

@@ -0,0 +1,76 @@
+import { IRPCCrudMeta, IRPCData, IRPCDriver, IRPCStub } from "./types.js";
+import { IRPCPackage } from "./module.js";
+
+//#region src/adapter.d.ts
+declare class NextDriver extends Error {
+  constructor();
+}
+/** Extracts operational method names from an adapter, excluding its own API. */
+type AttachableMethod<T> = string & keyof Omit<T, 'attach' | 'use' | 'dispatch'>;
+type AnyStub = IRPCStub<any, any[], any>;
+/**
+ * Attaches handlers to IRPC stubs and bridges them to drivers.
+ * Dispatches calls through the registered driver chain.
+ */
+declare class IRPCAdapter {
+  private module;
+  private drivers;
+  constructor(module: IRPCPackage);
+  /**
+   * Runs a get operation through the driver chain
+   * @param meta - Resolved entity metadata
+   * @param id - The entity identifier
+   */
+  get(meta: IRPCCrudMeta, id: IRPCData): Promise<IRPCData> | IRPCData;
+  /**
+   * Runs a create operation through the driver chain
+   * @param meta - Resolved entity metadata
+   * @param data - The entity data to create
+   */
+  create(meta: IRPCCrudMeta, data: IRPCData): Promise<IRPCData> | IRPCData;
+  /**
+   * Runs an update operation through the driver chain
+   * @param meta - Resolved entity metadata
+   * @param id - The entity identifier
+   * @param data - The entity data to update
+   */
+  update(meta: IRPCCrudMeta, id: IRPCData, data: IRPCData): Promise<IRPCData> | IRPCData;
+  /**
+   * Runs a delete operation through the driver chain
+   * @param meta - Resolved entity metadata
+   * @param id - The entity identifier
+   */
+  delete(meta: IRPCCrudMeta, id: IRPCData): Promise<IRPCData> | IRPCData;
+  /**
+   * Dispatches a method call through each registered driver in order
+   * @param method - The method name to dispatch
+   * @param meta - Resolved entity metadata
+   * @param args - Arguments forwarded to the driver method
+   * @throws CrudError.notImplemented if no driver handles the method
+   */
+  protected dispatch(method: string, meta: IRPCCrudMeta, ...args: IRPCData[]): Promise<IRPCData> | IRPCData;
+  /**
+   * Attaches a single stub to a specific method on this adapter
+   * @param stub - The stub function to attach
+   * @param method - The method name matching an adapter operation
+   * @throws CrudError.notFound if the stub is not registered in the package
+   */
+  attach(stub: AnyStub, method: AttachableMethod<this>): this;
+  /**
+   * Attaches stubs to this adapter by matching object keys to adapter methods
+   * @param stubs - Object mapping method names to stub functions
+   * @throws CrudError.notFound if a stub is not registered in the package
+   */
+  attach(stubs: Partial<Record<AttachableMethod<this>, AnyStub>>): this;
+  /**
+   * Registers a driver to handle dispatched operations
+   * @param driver - The driver implementation
+   */
+  use(driver: IRPCDriver): this;
+  /**
+   * Signals the current driver to pass execution to the next driver in the chain
+   */
+  static next(): NextDriver;
+}
+//#endregion
+export { IRPCAdapter };

package/dist/adapter.js

@@ -0,0 +1,109 @@
+import { CrudError } from "./error.js";
+
+//#region src/adapter.ts
+var NextDriver = class extends Error {
+	constructor() {
+		super("Next driver");
+	}
+};
+/**
+* Attaches handlers to IRPC stubs and bridges them to drivers.
+* Dispatches calls through the registered driver chain.
+*/
+var IRPCAdapter = class {
+	drivers = /* @__PURE__ */ new Set();
+	constructor(module) {
+		this.module = module;
+	}
+	/**
+	* Runs a get operation through the driver chain
+	* @param meta - Resolved entity metadata
+	* @param id - The entity identifier
+	*/
+	get(meta, id) {
+		return this.dispatch("get", meta, id);
+	}
+	/**
+	* Runs a create operation through the driver chain
+	* @param meta - Resolved entity metadata
+	* @param data - The entity data to create
+	*/
+	create(meta, data) {
+		return this.dispatch("create", meta, data);
+	}
+	/**
+	* Runs an update operation through the driver chain
+	* @param meta - Resolved entity metadata
+	* @param id - The entity identifier
+	* @param data - The entity data to update
+	*/
+	update(meta, id, data) {
+		return this.dispatch("update", meta, id, data);
+	}
+	/**
+	* Runs a delete operation through the driver chain
+	* @param meta - Resolved entity metadata
+	* @param id - The entity identifier
+	*/
+	delete(meta, id) {
+		return this.dispatch("delete", meta, id);
+	}
+	/**
+	* Dispatches a method call through each registered driver in order
+	* @param method - The method name to dispatch
+	* @param meta - Resolved entity metadata
+	* @param args - Arguments forwarded to the driver method
+	* @throws CrudError.notImplemented if no driver handles the method
+	*/
+	dispatch(method, meta, ...args) {
+		for (const driver of this.drivers) {
+			const fn = driver[method];
+			if (!fn) continue;
+			try {
+				return fn(meta, ...args);
+			} catch (err) {
+				if (err instanceof NextDriver) continue;
+				throw err;
+			}
+		}
+		throw CrudError.notImplemented(method);
+	}
+	attach(stubOrStubs, m) {
+		const stubs = m ? { [m]: stubOrStubs } : stubOrStubs;
+		const key = this.module.config.key ?? "id";
+		for (const [method, stub] of Object.entries(stubs)) {
+			if (!stub) continue;
+			const spec = this.module["stubs"].get(stub);
+			if (!spec) throw CrudError.notFound();
+			const meta = {
+				name: spec.name.replace(`.${method}`, ""),
+				key,
+				description: spec.description,
+				schema: spec.schema,
+				maxAge: spec.maxAge,
+				coalesce: spec.coalesce
+			};
+			this.module.construct(stub, ((...args) => {
+				return this[method](meta, ...args);
+			}));
+		}
+		return this;
+	}
+	/**
+	* Registers a driver to handle dispatched operations
+	* @param driver - The driver implementation
+	*/
+	use(driver) {
+		this.drivers.add(driver);
+		return this;
+	}
+	/**
+	* Signals the current driver to pass execution to the next driver in the chain
+	*/
+	static next() {
+		return new NextDriver();
+	}
+};
+
+//#endregion
+export { IRPCAdapter };

package/dist/call.js

@@ -1,5 +1,5 @@
-import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { CallError } from "./error.js";
+import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { IRPCReader } from "./reader.js";
 import { IRPC_STORE } from "./store.js";
 import { uuid } from "@anchorlib/core";

package/dist/error.d.ts

@@ -5,6 +5,7 @@ declare const IRPC_ERROR_TYPE: {
   readonly STUB: "stub";
   readonly HOOK: "hook";
   readonly CALL: "call";
+  readonly CRUD: "crud";
   readonly HANDLER: "handler";
   readonly RESOLVE: "resolve";
   readonly TRANSPORT: "transport";
@@ -47,6 +48,10 @@ declare const CALL_ERROR: {
   readonly MAX_RETRIES: "max_retries";
   readonly STREAM_ERROR: "stream_error";
 };
+declare const CRUD_ERROR: {
+  readonly NOT_FOUND: "not_found";
+  readonly NOT_IMPLEMENTED: "not_implemented";
+};
 /**
  * Base error class for all IRPC errors.
  *
@@ -112,5 +117,11 @@ declare class CallError extends IRPCError {
   static maxRetries(reasons: Set<Error>): CallError;
   static streamError(input: Error | string): CallError;
 }
+/** Errors related to CRUD adapter operations. */
+declare class CrudError extends IRPCError {
+  constructor(code: string, message: string, cause?: Error);
+  static notFound(): CrudError;
+  static notImplemented(method: string): CrudError;
+}
 //#endregion
-export { CALL_ERROR, CallError, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCError, IRPCErrorType, IRPC_ERROR_TYPE, RESOLVE_ERROR, ResolveError, STUB_ERROR, StubError, TRANSPORT_ERROR, TransportError };
+export { 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 };

package/dist/error.js

@@ -3,6 +3,7 @@ const IRPC_ERROR_TYPE = {
 	STUB: "stub",
 	HOOK: "hook",
 	CALL: "call",
+	CRUD: "crud",
 	HANDLER: "handler",
 	RESOLVE: "resolve",
 	TRANSPORT: "transport"
@@ -44,6 +45,10 @@ const CALL_ERROR = {
 	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,
@@ -199,14 +204,27 @@ var CallError = class CallError extends IRPCError {
 		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.CALL]: CallError,
+	[IRPC_ERROR_TYPE.CRUD]: CrudError
 };
 
 //#endregion
-export { CALL_ERROR, CallError, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCError, IRPC_ERROR_TYPE, RESOLVE_ERROR, ResolveError, STUB_ERROR, StubError, TRANSPORT_ERROR, TransportError };
+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_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, 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 { 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, 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 { 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 { 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 };
+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_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";
@@ -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 { 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 };
+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,38 @@ 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 seedOrConfig - The initial data seed function, or configuration object.
+   * @param config - Optional configuration (if seed was provided).
+   * @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, seedOrConfig: (() => IRPCReturnOf<F>) | (IRPCDeclareConfig<I, O> & IRPCInferInit<IRPCReturnOf<F>>), config?: IRPCDeclareConfig<I, O>): 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 +102,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 +152,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.
  *

package/dist/module.js

@@ -1,6 +1,6 @@
+import { HandlerError, ResolveError, StubError, TransportError } from "./error.js";
 import { IRPCCacher } from "./cache.js";
 import { IRPC_STATUS } from "./enum.js";
-import { HandlerError, ResolveError, StubError, TransportError } from "./error.js";
 import { getAbortSignal } from "./context.js";
 import { RemoteState } from "./state.js";
 import { IRPCReader } from "./reader.js";
@@ -37,6 +37,7 @@ var IRPCPackage = class {
 	config = {
 		name: "global",
 		version: "1.0.0",
+		key: "id",
 		timeout: DEFAULT_TIMEOUT
 	};
 	/**
@@ -71,13 +72,18 @@ var IRPCPackage = class {
 		this.configure(config ?? {});
 		IRPC_STORE.register(this);
 	}
-	/**
-	* Declares a new IRPC specification and creates a corresponding stub function
-	* @param options - The initialization object containing the IRPC specification
-	* @returns A stub function that can be used to call the IRPC
-	* @throws Error if an IRPC with the same name already exists
-	*/
-	declare(options) {
+	declare(nameOrOptions, seedOrConfig, config) {
+		let options;
+		if (typeof nameOrOptions === "string") if (typeof seedOrConfig === "function") options = {
+			name: nameOrOptions,
+			seed: seedOrConfig,
+			...config
+		};
+		else options = {
+			name: nameOrOptions,
+			...seedOrConfig
+		};
+		else options = nameOrOptions;
 		const $options = options;
 		if (this.specs.has($options.name)) throw StubError.duplicate($options.name);
 		if ($options.init && !$options.seed) $options.seed = $options.init;
@@ -156,22 +162,23 @@ var IRPCPackage = class {
 			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 } = {
+			const { timeout, maxRetries, retryDelay, retryMode, standalone } = {
 				...this.config,
 				...spec
 			};
-			const config = {
+			const config$1 = {
 				timeout,
 				maxRetries,
 				retryDelay,
-				retryMode
+				retryMode,
+				standalone
 			};
 			const hooks = this.hooks.get(spec);
 			if (hooks) hooks.forEach((hook) => hook({
 				name: spec.name,
 				args
 			}));
-			const call = typeof spec.handler === "function" ? intercept(spec, args, reader) : this.transport.call(spec, args, config, reader);
+			const call = typeof spec.handler === "function" ? intercept(spec, args, reader) : this.transport.call(spec, args, config$1, reader);
 			calls.set(callKey, call);
 			if (spec.maxAge) caches.set(callKey, call, spec.maxAge);
 			onCleanup(() => call.close());
@@ -185,6 +192,50 @@ var IRPCPackage = class {
 		return stub;
 	}
 	/**
+	* Declares CRUD stubs (get, create, update, delete) for an entity
+	* @param name - The entity name used as prefix for stub names
+	* @param seed - Factory function returning a default entity instance
+	* @param options - Optional configuration for caching, schemas, and call behavior
+	* @returns An object containing the four CRUD stub functions
+	*/
+	crud(name, seed, options) {
+		const { description, schema, maxAge, coalesce,...callConfig } = options ?? {};
+		const desc = (method) => typeof description === "string" ? description : description?.[method];
+		const init = (method) => ({
+			...callConfig,
+			name: `${name}.${method}`,
+			seed,
+			description: desc(method),
+			schema: schema?.[method],
+			...method === "get" ? { maxAge } : {},
+			coalesce
+		});
+		return {
+			get: this.declare(init("get")),
+			create: this.declare(init("create")),
+			update: this.declare(init("update")),
+			delete: this.declare(init("delete"))
+		};
+	}
+	/**
+	* Removes CRUD methods from a stubs object and unregisters their specs
+	* @param stubs - The CRUD stubs object to modify
+	* @param keys - The method names to remove
+	* @returns The stubs object without the excluded methods
+	*/
+	exclude(stubs, keys) {
+		for (const key of keys) {
+			const stub = stubs[key];
+			if (stub) {
+				const spec = this.stubs.get(stub);
+				if (spec) this.specs.delete(spec.name);
+				this.stubs.delete(stub);
+			}
+			delete stubs[key];
+		}
+		return stubs;
+	}
+	/**
 	* Resolves and executes an IRPC call based on a request object
 	* @param req - The request containing the IRPC name and arguments
 	* @returns The result of the IRPC execution
@@ -211,21 +262,21 @@ var IRPCPackage = class {
 		spec.handler = handler;
 		return this;
 	}
-	/**
-	* Registers a hook function for a specific stub function
-	* @param stub - The stub function created by declare()
-	* @param handler - The hook function to register
-	* @returns This IRPCPackage instance for chaining
-	* @throws Error if the stub is invalid or if no IRPC exists for the stub
-	*/
-	hook(stub, handler) {
-		if (!this.stubs.has(stub)) {
-			const error = StubError.notFound();
-			IRPC_STORE.error(error);
+	hook(stubOrGroup, handler) {
+		if (typeof stubOrGroup === "function") {
+			if (!this.stubs.has(stubOrGroup)) {
+				const error = StubError.notFound();
+				IRPC_STORE.error(error);
+				return this;
+			}
+			const spec = this.stubs.get(stubOrGroup);
+			this.hooks.get(spec).add(handler);
 			return this;
 		}
-		const spec = this.stubs.get(stub);
-		this.hooks.get(spec).add(handler);
+		for (const stub of Object.values(stubOrGroup)) if (typeof stub === "function" && this.stubs.has(stub)) {
+			const spec = this.stubs.get(stub);
+			this.hooks.get(spec).add(handler);
+		}
 		return this;
 	}
 	/**

package/dist/reader.js

@@ -1,5 +1,5 @@
-import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { IRPCError } from "./error.js";
+import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { RemoteState } from "./state.js";
 import { replay } from "@anchorlib/core";
 

package/dist/resolver.d.ts

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

package/dist/router.d.ts

@@ -1,6 +1,6 @@
-import { IRPCPackage } from "./module.js";
 import { IRPCTransport } from "./transport.js";
 import { IRPCPacketError, IRPCRequest } from "./types.js";
+import { IRPCPackage } from "./module.js";
 
 //#region src/router.d.ts
 type IRPCHook = () => void | Promise<void>;

package/dist/router.js

@@ -1,5 +1,5 @@
-import { IRPC_BASE_CONTEXT, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { HookError } from "./error.js";
+import { IRPC_BASE_CONTEXT, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { createContextStore, withContext } from "./context.js";
 import { IRPC_STORE } from "./store.js";
 

package/dist/state.js

@@ -1,5 +1,5 @@
-import { IRPC_STATUS } from "./enum.js";
 import { IRPCError, IRPC_ERROR_TYPE } from "./error.js";
+import { IRPC_STATUS } from "./enum.js";
 import { getAbortSignal } from "./context.js";
 import { $do, anchor, mutable, onCleanup, replay, subscribe } from "@anchorlib/core";
 

package/dist/store.d.ts

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

package/dist/stream.js

@@ -1,5 +1,5 @@
-import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { CallError, HandlerError, ResolveError } from "./error.js";
+import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { getAbortController, getAbortSignal } from "./context.js";
 import { RemoteState } from "./state.js";
 import { IRPC_STORE } from "./store.js";

package/dist/transport.d.ts

@@ -1,7 +1,7 @@
-import { IRPCPackage } from "./module.js";
+import { IRPCCall } from "./call.js";
 import { IRPCCallConfig, IRPCCredentials, IRPCCredentialsFactory, IRPCData, IRPCInputs, IRPCOutput, IRPCSpec, TransportConfig } from "./types.js";
 import { IRPCReader } from "./reader.js";
-import { IRPCCall } from "./call.js";
+import { IRPCPackage } from "./module.js";
 
 //#region src/transport.d.ts
 
@@ -12,7 +12,7 @@ import { IRPCCall } from "./call.js";
 declare class IRPCTransport {
   #private;
   config?: TransportConfig | undefined;
-  modules: Set<IRPCPackage>;
+  modules: Set<IRPCPackage<"id">>;
   /**
    * A set of pending RPC calls that are queued for execution.
    */
@@ -50,13 +50,23 @@ declare class IRPCTransport {
    */
   close(call: IRPCCall): void;
   /**
-   * Dispatches a batch of RPC calls. This base implementation rejects all calls
-   * with a "not implemented" error. Subclasses should override this method to
-   * provide actual transport mechanism.
+   * Dispatches RPC calls over the transport. Subclasses must override this
+   * to provide the actual transport mechanism (HTTP, WebSocket, etc.).
+   *
+   * When `standalone` is true, the call requires its own dedicated HTTP
+   * round-trip with full response lifecycle (cookies, headers). This is
+   * used for operations like authentication where `Set-Cookie` headers
+   * must flow back to the client. Only one call is dispatched at a time
+   * in standalone mode.
+   *
+   * When `standalone` is false or undefined, calls may be batched and
+   * streamed together in a single request.
+   *
    * @param calls - An array of RPC calls to dispatch.
+   * @param standalone - When true, dispatch as a dedicated request with full HTTP lifecycle.
    * @returns A promise that resolves when all calls have been processed.
    */
-  protected dispatch(calls: IRPCCall[]): Promise<void>;
+  protected dispatch(calls: IRPCCall[], standalone?: boolean): Promise<void>;
 }
 //#endregion
 export { IRPCTransport };

package/dist/transport.js

@@ -1,5 +1,5 @@
-import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { TransportError } from "./error.js";
+import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { IRPCReader } from "./reader.js";
 import { IRPC_STORE } from "./store.js";
 import { IRPCCall } from "./call.js";
@@ -55,8 +55,8 @@ var IRPCTransport = class {
 			retryMode,
 			retryDelay
 		}, reader);
-		if (spec.stream) {
-			this.dispatch([call]).finally(() => {}).catch((err) => IRPC_STORE.error(err, [{
+		if (spec.stream || config?.standalone) {
+			this.dispatch([call], config?.standalone).finally(() => {}).catch((err) => IRPC_STORE.error(err, [{
 				id: call.id,
 				name: call.payload.name
 			}]));
@@ -106,13 +106,23 @@ var IRPCTransport = class {
 		console.log("[irpc] Closing call", call);
 	}
 	/**
-	* Dispatches a batch of RPC calls. This base implementation rejects all calls
-	* with a "not implemented" error. Subclasses should override this method to
-	* provide actual transport mechanism.
+	* Dispatches RPC calls over the transport. Subclasses must override this
+	* to provide the actual transport mechanism (HTTP, WebSocket, etc.).
+	*
+	* When `standalone` is true, the call requires its own dedicated HTTP
+	* round-trip with full response lifecycle (cookies, headers). This is
+	* used for operations like authentication where `Set-Cookie` headers
+	* must flow back to the client. Only one call is dispatched at a time
+	* in standalone mode.
+	*
+	* When `standalone` is false or undefined, calls may be batched and
+	* streamed together in a single request.
+	*
 	* @param calls - An array of RPC calls to dispatch.
+	* @param standalone - When true, dispatch as a dedicated request with full HTTP lifecycle.
 	* @returns A promise that resolves when all calls have been processed.
 	*/
-	async dispatch(calls) {
+	async dispatch(calls, standalone) {
 		calls.forEach((call) => {
 			call.enqueue({
 				id: call.id,

package/dist/types.d.ts

@@ -160,6 +160,8 @@ type IRPCPackageInfo = {
   description?: string;
 };
 type IRPCPackageConfig = IRPCPackageInfo & IRPCCallConfig & {
+  /** Primary key field name for CRUD operations. Defaults to 'id'. */
+  key?: string;
   transport?: IRPCTransport;
 };
 /**
@@ -214,6 +216,28 @@ type IRPCInferInit<R$1> = R$1 extends IRPCDefined ? {
 } : {
   seed?: () => R$1;
 };
+/**
+ * Extracts the data type from a function's return type by unwrapping
+ * RemoteState and Promise wrappers.
+ *
+ * @template F - The function type to extract from.
+ */
+type IRPCReturnOf<F> = F extends ((...args: infer _A) => infer R) ? R extends RemoteState<infer S> ? S : R extends Promise<infer D> ? D : R : IRPCData;
+/**
+ * Configuration options for the shorthand `declare(name, seed, config?)` overload.
+ * Contains all IRPCInit fields except `name` and `seed`.
+ *
+ * @template I - Tuple of input validation schemas
+ * @template O - Output validation schema
+ */
+type IRPCDeclareConfig<I extends IRPCInputs = IRPCInputs, O$1 extends IRPCOutput = IRPCOutput> = {
+  description?: string;
+  schema?: IRPCSchema<I, O$1>;
+  maxAge?: number;
+  coalesce?: boolean;
+  stream?: true;
+  ttl?: number;
+} & IRPCCallConfig;
 /**
  * Configuration options for initializing an RPC stream function.
  * Contains metadata and constraints for the RPC stream function.
@@ -234,6 +258,64 @@ type IRPCStreamInit<I extends IRPCInputs, O$1 extends IRPCOutput, R$1> = IRPCIni
  * @template O - Output validation schema
  */
 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>;
+type IRPCCrudMethod = 'get' | 'create' | 'update' | 'delete';
+/**
+ * Discriminated field — shared value or per-operation values.
+ */
+type IRPCCrudField<T> = T | {
+  get?: T;
+  create?: T;
+  update?: T;
+  delete?: T;
+};
+type IRPCCrudOptions = {
+  description?: IRPCCrudField<string>;
+  schema?: {
+    get?: IRPCSchema<IRPCInputs, IRPCOutput>;
+    create?: IRPCSchema<IRPCInputs, IRPCOutput>;
+    update?: IRPCSchema<IRPCInputs, IRPCOutput>;
+    delete?: IRPCSchema<IRPCInputs, IRPCOutput>;
+  };
+  /** Cache max age — only applied to get. */
+  maxAge?: number;
+  coalesce?: boolean;
+} & IRPCCallConfig;
+/**
+ * ID type extracted from entity using the key field.
+ * Falls back to string if the key doesn't exist on the entity.
+ */
+type IRPCEntityId<T, K$1 extends string> = K$1 extends keyof T ? T[K$1] : string;
+type IRPCCrudStubs<T extends IRPCObject, K$1 extends string, I extends IRPCObject = T, U extends IRPCObject = T> = {
+  get: IRPCFunction<(id: IRPCEntityId<T, K$1>) => Promise<T> | RemoteState<T>>;
+  create: IRPCFunction<(data: I) => Promise<T> | RemoteState<T>>;
+  update: IRPCFunction<(id: IRPCEntityId<T, K$1>, data: U) => Promise<T> | RemoteState<T>>;
+  delete: IRPCFunction<(id: IRPCEntityId<T, K$1>) => Promise<T> | RemoteState<T>>;
+};
+/**
+ * Per-method resolved metadata — discriminated fields flattened,
+ * method-specific options applied. Passed to driver on every call.
+ */
+type IRPCCrudMeta = {
+  /** Entity/table name. */
+  name: string;
+  /** Primary key field name. */
+  key: string;
+  /** Resolved description for this method. */
+  description?: string;
+  /** Resolved schema for this method. */
+  schema?: IRPCSchema<IRPCInputs, IRPCOutput>;
+  maxAge?: number;
+  coalesce?: boolean;
+} & IRPCCallConfig;
+/**
+ * Base class for CRUD drivers that receive per-method resolved metadata on every call
+ */
+declare abstract class IRPCDriver {
+  get?(meta: IRPCCrudMeta, id: IRPCData): Promise<IRPCData> | IRPCData;
+  create?(meta: IRPCCrudMeta, data: IRPCData): Promise<IRPCData> | IRPCData;
+  update?(meta: IRPCCrudMeta, id: IRPCData, data: IRPCData): Promise<IRPCData> | IRPCData;
+  delete?(meta: IRPCCrudMeta, id: IRPCData): Promise<IRPCData> | IRPCData;
+}
 /**
  * Complete specification for an RPC function including its implementation.
  * Extends IRPCInit with the actual handler function.
@@ -314,6 +396,8 @@ type IRPCCallConfig = {
   retryMode?: 'linear' | 'exponential';
   /** Base delay between retries in milliseconds */
   retryDelay?: number;
+  /** Optional flag to dispatch the call as a standalone HTTP request with full cookie/header lifecycle */
+  standalone?: boolean;
 };
 /**
  * Configuration for transport layer, extending call configuration with debounce settings.
@@ -335,4 +419,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, 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 };
+export { 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 };

package/dist/types.js

@@ -1 +1,8 @@
-export {  };
+//#region src/types.ts
+/**
+* Base class for CRUD drivers that receive per-method resolved metadata on every call
+*/
+var IRPCDriver = class {};
+
+//#endregion
+export { IRPCDriver };

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@irpclib/irpc",
-  "version": "1.0.0-beta.25",
+  "version": "1.1.0",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
   "exports": {
@@ -36,6 +36,7 @@
     "zod": "^4.1.5"
   },
   "peerDependencies": {
+    "@anchorlib/core": "^1.1.0",
     "typescript": "^5.9.3"
   },
   "optionalDependencies": {
@@ -44,14 +45,11 @@
   "scripts": {
     "dev": "rimraf dist && tsdown --watch ./src",
     "clean": "rimraf dist",
-    "build": "rimraf dist && tsdown && publint",
+    "build": "bun run clean && tsdown && publint",
     "format": "biome format --write",
     "test": "rimraf coverage && vitest --run",
     "test:preview": "rimraf coverage && vitest --run && vite preview --outDir coverage",
-    "prepublish": "bun run format && bun run clean && tsdown && publint"
+    "prepublish": "bun run format && bun run build"
   },
-  "license": "MIT",
-  "dependencies": {
-    "@anchorlib/core": "^1.0.0-beta.25"
-  }
+  "license": "MIT"
 }