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

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

@@ -31,6 +31,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";

package/dist/enum.js

@@ -30,7 +30,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",

package/dist/error.d.ts

@@ -24,6 +24,8 @@ declare const ERROR_CODE: {
   RESOLVER_NOT_FOUND: string;
   RESOLVER_NOT_SUPPORTED: string;
   STREAM_ERROR: string;
+  HANDLER_ERROR: string;
+  RESOLVE_ERROR: string;
   CALL_MAX_RETRIES_REACHED: string;
 };
 type ErrorCode = (typeof ERROR_CODE)[keyof typeof ERROR_CODE];
@@ -46,6 +48,8 @@ declare const ERROR_MESSAGE: {
   [ERROR_CODE.TRANSPORT_NOT_IMPLEMENTED]: string;
   [ERROR_CODE.STUB_INVALID]: string;
   [ERROR_CODE.STREAM_ERROR]: string;
+  [ERROR_CODE.HANDLER_ERROR]: string;
+  [ERROR_CODE.RESOLVE_ERROR]: string;
   [ERROR_CODE.STUB_NOT_IMPLEMENTED]: string;
   [ERROR_CODE.RESOLVER_MISSING]: string;
   [ERROR_CODE.RESOLVER_NOT_IMPLEMENTED]: string;

package/dist/error.js

@@ -24,6 +24,8 @@ const ERROR_CODE = {
 	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 = {
@@ -45,6 +47,8 @@ const ERROR_MESSAGE = {
 	[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",

package/dist/index.d.ts

@@ -2,17 +2,18 @@ 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 { 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, 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 { 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 { 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 { 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 };

package/dist/index.js

@@ -1,7 +1,7 @@
 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 { createContext, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext } from "./context.js";
+import { createContext, createContextStore, getAbortController, getAbortSignal, getContext, setContext, setContextProvider, withContext } from "./context.js";
 import { RemoteState, stream } from "./state.js";
 import { IRPCReader } from "./reader.js";
 import { IRPCTransport } from "./transport.js";
@@ -10,9 +10,10 @@ import { IRPCRouter } from "./router.js";
 import { IRPCStream } from "./stream.js";
 import { IRPCStore, IRPC_STORE } from "./store.js";
 import { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, IRPCCall } from "./call.js";
+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 { 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, createPackage, decode, encode, getAbortController, getAbortSignal, getContext, intercept, isFilePointer, plan, setContext, setContextProvider, stream, withContext };
+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 };

package/dist/module.js

@@ -1,6 +1,7 @@
 import { IRPCCacher } from "./cache.js";
 import { IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { getAbortSignal } from "./context.js";
 import { RemoteState } from "./state.js";
 import { IRPCReader } from "./reader.js";
 import { IRPCTransport } from "./transport.js";
@@ -98,6 +99,23 @@ var IRPCPackage = class {
 		stub.when = (getArgs, debounce) => {
 			return prepare(typeof getArgs === "function" ? getArgs : () => getArgs, true, debounce);
 		};
+		stub.later = (debounce) => {
+			const reader = new IRPCReader(uuid(), spec.init(), IRPC_STATUS.IDLE, true);
+			if (debounce) {
+				const [schedule, cancel] = microtask(debounce);
+				reader.dispatch = (...args) => schedule(() => {
+					reader.resume();
+					execute(args, reader);
+				});
+				onCleanup(cancel);
+				return reader;
+			}
+			reader.dispatch = (...args) => {
+				reader.resume();
+				execute(args, reader);
+			};
+			return reader;
+		};
 		/**
 		* A preparation utility to generate and schedule call on the browser environment.
 		*
@@ -230,6 +248,8 @@ var IRPCPackage = class {
 	*/
 	use(transport) {
 		if (!(transport instanceof IRPCTransport)) throw new Error(ERROR_MESSAGE[ERROR_CODE.TRANSPORT_INVALID]);
+		if (this.transport) this.transport.modules.delete(this);
+		transport.modules.add(this);
 		this.config.transport = transport;
 		return this;
 	}
@@ -283,10 +303,18 @@ function createPackage(config) {
 * @returns {IRPCReader<IRPCData>} - The IRPCReader object for consumer.
 */
 function intercept(spec, args, reader) {
+	const signal = getAbortSignal();
+	if (signal?.aborted) {
+		reader.abort();
+		return reader;
+	}
+	const abort = () => reader.abort();
+	signal?.addEventListener("abort", abort, { once: true });
 	try {
 		const result = spec.handler(...args);
 		if (!(result instanceof Promise)) {
 			reader.accept(result);
+			signal?.removeEventListener("abort", abort);
 			return reader;
 		}
 		if (!(result instanceof RemoteState)) {
@@ -294,6 +322,8 @@ function intercept(spec, args, reader) {
 				reader.accept(value);
 			}).catch((err) => {
 				reader.reject(err);
+			}).finally(() => {
+				signal?.removeEventListener("abort", abort);
 			});
 			return reader;
 		}
@@ -303,13 +333,24 @@ function intercept(spec, args, reader) {
 			const [rootKey] = event.keys;
 			if (rootKey === "status") {
 				reader.status = event.value;
-				if (reader.status === IRPC_STATUS.SUCCESS) unsubscribe();
+				if (reader.status === IRPC_STATUS.SUCCESS || reader.status === IRPC_STATUS.ERROR) {
+					signal?.removeEventListener("abort", subAbort);
+					unsubscribe();
+				}
 				return;
 			}
 			replay(reader.state, event);
 		});
+		const subAbort = () => {
+			unsubscribe();
+			reader.abort();
+			result.abort();
+		};
+		signal?.addEventListener("abort", subAbort, { once: true });
+		signal?.removeEventListener("abort", abort);
 	} catch (error) {
 		reader.reject(error);
+		signal?.removeEventListener("abort", abort);
 	}
 	return reader;
 }

package/dist/reader.d.ts

@@ -17,8 +17,9 @@ declare class IRPCReader<T extends IRPCData> extends RemoteState<T> {
    * @param id - The unique identifier for this state instance.
    * @param init - An optional starting value for the data payload.
    * @param status - The initial status of the state (PENDING, SUCCESS, ERROR).
+   * @param resumable - Whether the state should be resumable after being closed.
    */
-  constructor(id: string, init?: T, status?: IRPCStatus);
+  constructor(id: string, init?: T, status?: IRPCStatus, resumable?: boolean);
   /**
    * Pushes incoming network packets into this reader, evaluating payload data
    * and subsequently updating the core state values locally.

package/dist/reader.js

@@ -16,9 +16,10 @@ var IRPCReader = class extends RemoteState {
 	* @param id - The unique identifier for this state instance.
 	* @param init - An optional starting value for the data payload.
 	* @param status - The initial status of the state (PENDING, SUCCESS, ERROR).
+	* @param resumable - Whether the state should be resumable after being closed.
 	*/
-	constructor(id, init, status = IRPC_STATUS.PENDING) {
-		super(init, status);
+	constructor(id, init, status = IRPC_STATUS.PENDING, resumable) {
+		super(init, status, resumable);
 		this.id = id;
 	}
 	/**

package/dist/resolver.d.ts

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

package/dist/resolver.js

@@ -96,7 +96,25 @@ var IRPCResolver = class {
 					result
 				};
 			}
-			const output = parseOutput(await result, schema);
+			const data = await result;
+			if (data instanceof RemoteState) {
+				data.unpipe();
+				const output$1 = parseOutput(data.data, schema);
+				if (!output$1.success) return {
+					id,
+					name,
+					error: {
+						code: ERROR_CODE.INVALID_OUTPUT,
+						message: output$1.error?.message
+					}
+				};
+				return {
+					id,
+					name,
+					result: data
+				};
+			}
+			const output = parseOutput(data, schema);
 			if (output.success) return {
 				id,
 				name,
@@ -115,7 +133,7 @@ var IRPCResolver = class {
 				id,
 				name,
 				error: {
-					code: ERROR_CODE.UNKNOWN,
+					code: ERROR_CODE.HANDLER_ERROR,
 					message: error.message
 				}
 			};

package/dist/router.d.ts

@@ -1,6 +1,6 @@
+import { IRPCPackage } from "./module.js";
 import { IRPCTransport } from "./transport.js";
 import { IRPCRequest } from "./types.js";
-import { IRPCPackage } from "./module.js";
 
 //#region src/router.d.ts
 type IRPCHook = () => void | Promise<void>;
@@ -21,6 +21,17 @@ declare class IRPCRouter {
    * @returns The current Router instance for chaining
    */
   use(hook: IRPCHook): this;
+  /**
+   * Run a function within an isolated IRPC Router context.
+   * This make sure any subsequent RPC calls will be seeded with the hooks added to the router.
+   *
+   * @param handler - The handler function to isolate
+   * @param controller - The AbortController to use for cancellation
+   * @param context - Additional context to pass to the handler
+   * @param preHook - A hook function to run before the router hooks
+   * @returns The result of the isolated handler function
+   */
+  isolate<T>(handler: () => T | Promise<T>, controller: AbortController, context?: Array<[string | symbol, unknown]>, preHook?: IRPCHook): Promise<Promise<T>>;
   /**
    * Resolves hook functions for a given request
    * @param req - The IRPC request to process hook for

package/dist/router.js

@@ -1,5 +1,6 @@
-import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
+import { IRPC_BASE_CONTEXT, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { createContextStore, withContext } from "./context.js";
 import { IRPC_STORE } from "./store.js";
 
 //#region src/router.ts
@@ -31,6 +32,27 @@ var IRPCRouter = class {
 		return this;
 	}
 	/**
+	* Run a function within an isolated IRPC Router context.
+	* This make sure any subsequent RPC calls will be seeded with the hooks added to the router.
+	*
+	* @param handler - The handler function to isolate
+	* @param controller - The AbortController to use for cancellation
+	* @param context - Additional context to pass to the handler
+	* @param preHook - A hook function to run before the router hooks
+	* @returns The result of the isolated handler function
+	*/
+	isolate(handler, controller, context = [], preHook) {
+		return withContext(createContextStore([
+			[IRPC_BASE_CONTEXT.ABORT_SIGNAL, controller.signal],
+			[IRPC_BASE_CONTEXT.ABORT_CONTROLLER, controller],
+			...context
+		]), async () => {
+			await preHook?.();
+			for (const hook of this.hooks) await hook();
+			return handler();
+		});
+	}
+	/**
 	* Resolves hook functions for a given request
 	* @param req - The IRPC request to process hook for
 	* @returns An error response if hook fails, undefined otherwise

package/dist/state.d.ts

@@ -15,6 +15,7 @@ import { StateSubscriber } from "@anchorlib/core";
  */
 declare class RemoteState<T> extends Promise<T> {
   #private;
+  private resumable?;
   get state(): IRPCReadable<T>;
   /**
    * The current data payload of the state.
@@ -37,8 +38,9 @@ declare class RemoteState<T> extends Promise<T> {
    *
    * @param init - An optional starting value for the data payload.
    * @param status - The initial status of the state (PENDING, SUCCESS, ERROR).
+   * @param resumable - Whether the state should be resumable after being closed.
    */
-  constructor(init?: T, status?: IRPCStatus);
+  constructor(init?: T, status?: IRPCStatus, resumable?: boolean | undefined);
   accept(value?: T): void;
   reject(error?: Error): void;
   abort(): void;
@@ -53,6 +55,9 @@ declare class RemoteState<T> extends Promise<T> {
    * Closes the reactive state and terminates the underlying Promise.
    */
   close(): void;
+  protected resume(): void;
+  pipe(): this;
+  unpipe(): this;
   /**
    * Destroys the reactive state bindings.
    */

package/dist/state.js

@@ -18,6 +18,7 @@ var RemoteState = class extends Promise {
 	#accept;
 	#reject;
 	#closed = false;
+	#locked;
 	get state() {
 		return this.#state;
 	}
@@ -59,14 +60,17 @@ var RemoteState = class extends Promise {
 	*
 	* @param init - An optional starting value for the data payload.
 	* @param status - The initial status of the state (PENDING, SUCCESS, ERROR).
+	* @param resumable - Whether the state should be resumable after being closed.
 	*/
-	constructor(init, status = IRPC_STATUS.PENDING) {
+	constructor(init, status = IRPC_STATUS.PENDING, resumable) {
 		let acceptFn;
 		let rejectFn;
 		super((resolve, reject) => {
+			if (resumable) resolve(init);
 			acceptFn = resolve;
 			rejectFn = reject;
 		});
+		this.resumable = resumable;
 		this.#accept = acceptFn;
 		this.#reject = rejectFn;
 		this.#state = mutable({
@@ -123,10 +127,25 @@ var RemoteState = class extends Promise {
 		this.#accept(this.data);
 		this.destroy();
 	}
+	resume() {
+		this.#closed = false;
+	}
+	pipe() {
+		this.#locked = this.then;
+		this.then = void 0;
+		return this;
+	}
+	unpipe() {
+		if (!this.#locked) return this;
+		this.then = this.#locked;
+		this.#locked = void 0;
+		return this;
+	}
 	/**
 	* Destroys the reactive state bindings.
 	*/
 	destroy() {
+		if (this.resumable) return;
 		anchor.destroy(this.state);
 	}
 	/**

package/dist/store.d.ts

@@ -1,6 +1,6 @@
 import { IRPC_STORE_EVENT } from "./enum.js";
-import { IRPCData } from "./types.js";
 import { IRPCPackage } from "./module.js";
+import { IRPCData } from "./types.js";
 import { IRPCRouter } from "./router.js";
 import { IRPCStream } from "./stream.js";
 

package/dist/stream.js

@@ -69,7 +69,7 @@ var IRPCStream = class {
 				if (result.status === IRPC_STATUS.SUCCESS || result.status === IRPC_STATUS.ERROR) {
 					if (result.status === IRPC_STATUS.ERROR) {
 						this.error = {
-							code: ERROR_CODE.STREAM_ERROR,
+							code: ERROR_CODE.HANDLER_ERROR,
 							message: result.error.message
 						};
 						this.status = IRPC_STATUS.ERROR;
@@ -148,10 +148,7 @@ var IRPCStream = class {
 			} else {
 				this.value = result;
 				if (response.error) {
-					this.error = {
-						code: ERROR_CODE.STREAM_ERROR,
-						message: response.error.message
-					};
+					this.error = response.error;
 					this.status = IRPC_STATUS.ERROR;
 					this.errorHandlers.forEach((handler) => handler(this.error));
 				} else this.status = IRPC_STATUS.SUCCESS;
@@ -173,7 +170,7 @@ var IRPCStream = class {
 				name: this.name
 			}]);
 			this.error = {
-				code: ERROR_CODE.STREAM_ERROR,
+				code: ERROR_CODE.RESOLVE_ERROR,
 				message: error.message
 			};
 			this.status = IRPC_STATUS.ERROR;

package/dist/transport.d.ts

@@ -1,4 +1,5 @@
-import { IRPCCallConfig, IRPCData, IRPCInputs, IRPCOutput, IRPCSpec, TransportConfig } from "./types.js";
+import { IRPCPackage } from "./module.js";
+import { IRPCCallConfig, IRPCCredentials, IRPCCredentialsFactory, IRPCData, IRPCInputs, IRPCOutput, IRPCSpec, TransportConfig } from "./types.js";
 import { IRPCReader } from "./reader.js";
 import { IRPCCall } from "./call.js";
 
@@ -9,11 +10,14 @@ import { IRPCCall } from "./call.js";
  * It handles queuing, debouncing, and timeout management for RPC requests.
  */
 declare class IRPCTransport {
+  #private;
   config?: TransportConfig | undefined;
+  modules: Set<IRPCPackage>;
   /**
    * A set of pending RPC calls that are queued for execution.
    */
   queue: Set<IRPCCall>;
+  get credentials(): IRPCCredentials;
   /**
    * Creates a new IRPCTransport instance.
    * @param config - Optional transport configuration including timeout and debounce settings.
@@ -34,6 +38,11 @@ declare class IRPCTransport {
    * @param call - The RPC call to schedule.
    */
   schedule(call: IRPCCall): void;
+  /**
+   * Signs an RPC call with credentials.
+   * @param cred - The credentials to sign the call with.
+   */
+  sign(cred: IRPCCredentialsFactory): void;
   /**
    * Closes an RPC call. This base implementation does nothing.
    * Subclasses should override this method to provide closing logic.

package/dist/transport.js

@@ -11,10 +11,20 @@ import { onCleanup, uuid } from "@anchorlib/core";
 * It handles queuing, debouncing, and timeout management for RPC requests.
 */
 var IRPCTransport = class {
+	#credentialFactory;
+	modules = /* @__PURE__ */ new Set();
 	/**
 	* A set of pending RPC calls that are queued for execution.
 	*/
 	queue = /* @__PURE__ */ new Set();
+	get credentials() {
+		if (typeof this.#credentialFactory === "function") {
+			const cred = this.#credentialFactory();
+			if (cred === null || Array.isArray(cred) || typeof cred !== "object") return [];
+			return Object.entries(cred);
+		}
+		return Object.entries(this.#credentialFactory ?? {});
+	}
 	/**
 	* Creates a new IRPCTransport instance.
 	* @param config - Optional transport configuration including timeout and debounce settings.
@@ -80,6 +90,14 @@ var IRPCTransport = class {
 		this.queue.add(call);
 	}
 	/**
+	* Signs an RPC call with credentials.
+	* @param cred - The credentials to sign the call with.
+	*/
+	sign(cred) {
+		if (cred === null || Array.isArray(cred) || typeof cred !== "object" && typeof cred !== "function") return;
+		this.#credentialFactory = cred;
+	}
+	/**
 	* Closes an RPC call. This base implementation does nothing.
 	* Subclasses should override this method to provide closing logic.
 	* @param call - The RPC call to cancel.

package/dist/types.d.ts

@@ -1,10 +1,11 @@
 import { IRPC_BASE_CONTEXT, IRPC_DATA_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ErrorCode } from "./error.js";
 import { IRPCFile } from "./file.js";
+import { IRPCFilePointer } from "./packet.js";
 import { IRPCTransport } from "./transport.js";
 import { RemoteState } from "./state.js";
 import { IRPCReader } from "./reader.js";
-import { StateChange } from "@anchorlib/core";
+import { AsyncValue, StateChange } from "@anchorlib/core";
 import { ZodArray, ZodBoolean, ZodNull, ZodNumber, ZodObject, ZodSafeParseResult, ZodString, ZodUndefined } from "zod/v4";
 
 //#region src/types.d.ts
@@ -89,6 +90,9 @@ interface IRPCStub<T, A$1 extends unknown[], R$1 extends IRPCData> {
    * @returns An IRPCReader instance for handling the asynchronous result or stream.
    */
   when(args: () => A$1, debounce?: number): IRPCReader<R$1>;
+  later(debounce?: number): IRPCReader<R$1> & {
+    dispatch: (...args: A$1) => void;
+  };
 }
 /**
  * A utility type that transforms a standard function type into its corresponding IRPCStub.
@@ -252,6 +256,13 @@ type IRPCRequest = {
   name: string;
   /** Arguments for the RPC function */
   args: unknown[];
+  files?: IRPCFilePointer[];
+};
+type IRPCCredentials = Iterable<[string, AsyncValue]>;
+type IRPCCredentialsFactory = Record<string, AsyncValue> | (() => Record<string, AsyncValue>);
+type IRPCRequests = {
+  calls: IRPCRequest[];
+  credentials?: IRPCCredentials;
 };
 type IRPCError = {
   code: ErrorCode;
@@ -322,4 +333,4 @@ type StreamCleanup = () => void;
  */
 type StreamConstructor<T> = (state: IRPCReadable<T>, resolve: (value?: T) => void, reject: (error: Error) => void) => StreamCleanup | void | Promise<StreamCleanup | void>;
 //#endregion
-export { IRPCArraySchema, IRPCBaseContext, IRPCCallConfig, IRPCContext, IRPCContextProvider, 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 };
+export { IRPCArraySchema, IRPCBaseContext, IRPCCallConfig, IRPCContext, IRPCContextProvider, IRPCCredentials, IRPCCredentialsFactory, IRPCData, IRPCDataSchema, IRPCDataType, IRPCDeclareInit, IRPCError, IRPCFunction, IRPCHandler, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketEvent, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCRequest, IRPCRequests, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStreamInit, IRPCStub, IRPCStubStore, StreamCleanup, StreamConstructor, TransportConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@irpclib/irpc",
-  "version": "1.0.0-beta.23",
+  "version": "1.0.0-beta.24",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
   "exports": {
@@ -50,6 +50,6 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@anchorlib/core": "^1.0.0-beta.23"
+    "@anchorlib/core": "^1.0.0-beta.24"
   }
 }