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

package/dist/stream.js

@@ -1,6 +1,8 @@
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE } from "./error.js";
+import { getAbortController, getAbortSignal } from "./context.js";
 import { RemoteState } from "./state.js";
+import { IRPC_STORE } from "./store.js";
 
 //#region src/stream.ts
 /**
@@ -18,34 +20,56 @@ var IRPCStream = class {
 	value;
 	error;
 	status = IRPC_STATUS.IDLE;
+	closed = false;
+	createdAt = Date.now();
+	startedAt;
+	updatedAt;
+	controller;
 	/**
 	* Initializes a stream wrapping an asynchronous RPC execution.
 	*
 	* @param id - The unique identifier of the RPC request.
 	* @param name - The name of the specification processing the execution.
 	* @param initializer - An execution callback that yields an IRPCResponse.
+	* @param spec - The specification for the RPC execution.
+	* @param router - The router instance managing the stream.
 	*/
-	constructor(id, name, initializer) {
+	constructor(id, name, initializer, spec, router) {
 		this.id = id;
 		this.name = name;
 		this.initializer = initializer;
+		this.spec = spec;
+		this.router = router;
+		IRPC_STORE.queue(this);
 	}
 	/**
 	* Evaluates the underlying initializer and propagates standard transport packets
 	* to all bound pipe handlers based on the output lifecycle.
 	*/
 	async start() {
-		if (this.status !== IRPC_STATUS.IDLE) return;
+		if (this.status !== IRPC_STATUS.IDLE || this.closed) return;
+		this.startedAt = Date.now();
+		this.controller = getAbortController();
+		const abortSignal = getAbortSignal();
+		if (abortSignal?.aborted) {
+			this.finish();
+			return;
+		}
 		this.status = IRPC_STATUS.PENDING;
 		const { id, name } = this;
 		try {
-			const { result } = await this.initializer();
+			const response = await this.initializer();
+			if (abortSignal?.aborted) {
+				this.finish();
+				return;
+			}
+			const { result } = response;
 			if (result instanceof RemoteState) {
 				this.value = result.data;
 				if (result.status === IRPC_STATUS.SUCCESS || result.status === IRPC_STATUS.ERROR) {
 					if (result.status === IRPC_STATUS.ERROR) {
 						this.error = {
-							code: ERROR_CODE.STREAM_ERROR,
+							code: ERROR_CODE.HANDLER_ERROR,
 							message: result.error.message
 						};
 						this.status = IRPC_STATUS.ERROR;
@@ -60,8 +84,8 @@ var IRPCStream = class {
 						createdAt: Date.now()
 					};
 					this.pipeHandlers.forEach((handler) => handler(packet));
-					this.errorHandlers.forEach((handler) => handler(this.error));
-					this.closeHandlers.forEach((handler) => handler());
+					if (this.error) this.errorHandlers.forEach((handler) => handler(this.error));
+					this.finish();
 					return;
 				}
 				this.pipeHandlers.forEach((handler) => {
@@ -81,13 +105,13 @@ var IRPCStream = class {
 						handler({
 							id,
 							name,
-							type: IRPC_PACKET_TYPE.EVENT,
-							status: state.status,
 							data: {
 								type,
 								keys,
 								value
 							},
+							type: IRPC_PACKET_TYPE.EVENT,
+							status: state.status,
 							createdAt: Date.now()
 						});
 					});
@@ -111,27 +135,42 @@ var IRPCStream = class {
 								createdAt: Date.now()
 							});
 						});
-						this.closeHandlers.forEach((handler) => handler());
+						abortSignal?.removeEventListener("abort", abortStream);
+						this.finish();
 						unsubscribe();
 					}
 				});
+				const abortStream = () => {
+					unsubscribe();
+					this.finish();
+				};
+				abortSignal?.addEventListener("abort", abortStream, { once: true });
 			} else {
 				this.value = result;
-				this.status = IRPC_STATUS.SUCCESS;
+				if (response.error) {
+					this.error = response.error;
+					this.status = IRPC_STATUS.ERROR;
+					this.errorHandlers.forEach((handler) => handler(this.error));
+				} else this.status = IRPC_STATUS.SUCCESS;
 				const packet = {
 					id,
 					name,
 					type: IRPC_PACKET_TYPE.ANSWER,
-					status: IRPC_STATUS.SUCCESS,
 					data: this.value,
+					error: this.error,
+					status: this.status,
 					createdAt: Date.now()
 				};
 				this.pipeHandlers.forEach((handler) => handler(packet));
-				this.closeHandlers.forEach((handler) => handler());
+				this.finish();
 			}
 		} catch (error) {
+			IRPC_STORE.error(error, [{
+				id: this.id,
+				name: this.name
+			}]);
 			this.error = {
-				code: ERROR_CODE.STREAM_ERROR,
+				code: ERROR_CODE.RESOLVE_ERROR,
 				message: error.message
 			};
 			this.status = IRPC_STATUS.ERROR;
@@ -146,7 +185,7 @@ var IRPCStream = class {
 				});
 			});
 			this.errorHandlers.forEach((handler) => handler(this.error));
-			this.closeHandlers.forEach((handler) => handler());
+			this.finish();
 			return;
 		}
 	}
@@ -169,8 +208,12 @@ var IRPCStream = class {
 			});
 			return;
 		}
+		if (this.closed) return;
 		this.pipeHandlers.add(handler);
-		this.start().catch(() => {});
+		this.start().catch((err) => IRPC_STORE.error(err, [{
+			id: this.id,
+			name: this.name
+		}]));
 	}
 	/**
 	* Binds a handler to trap any internal runtime failures independently.
@@ -182,8 +225,12 @@ var IRPCStream = class {
 			handler(this.error);
 			return;
 		}
+		if (this.closed) return;
 		this.errorHandlers.add(handler);
-		this.start().catch(() => {});
+		this.start().catch((err) => IRPC_STORE.error(err, [{
+			id: this.id,
+			name: this.name
+		}]));
 	}
 	/**
 	* Binds a handler triggered upon terminal completion of the stream process (success or error).
@@ -195,8 +242,21 @@ var IRPCStream = class {
 			handler();
 			return;
 		}
+		if (this.closed) return;
 		this.closeHandlers.add(handler);
-		this.start().catch(() => {});
+		this.start().catch((err) => IRPC_STORE.error(err, [{
+			id: this.id,
+			name: this.name
+		}]));
+	}
+	finish() {
+		this.closed = true;
+		this.closeHandlers.forEach((handler) => handler());
+		this.pipeHandlers.clear();
+		this.errorHandlers.clear();
+		this.closeHandlers.clear();
+		this.updatedAt = Date.now();
+		IRPC_STORE.dequeue(this);
 	}
 };
 

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.
@@ -21,18 +25,30 @@ declare class IRPCTransport {
   constructor(config?: TransportConfig | undefined);
   /**
    * Initiates an RPC call with the given specification and arguments.
+   * @param reader - The reader instance to attach to the RPC call.
    * @param spec - The RPC specification defining the method to call.
    * @param args - An array of arguments to pass to the RPC method.
    * @param config - Optional call configuration, including timeout, retry settings, and more.
    * @returns A promise that resolves with the RPC response data or rejects with an error.
    */
-  call(spec: IRPCSpec<IRPCInputs, IRPCOutput>, args: IRPCData[], config?: IRPCCallConfig): IRPCReader<IRPCData>;
+  call(spec: IRPCSpec<IRPCInputs, IRPCOutput>, args: IRPCData[], config?: IRPCCallConfig, reader?: IRPCReader<IRPCData>): IRPCReader<IRPCData>;
   /**
    * Schedules an RPC call for execution, implementing debouncing logic.
    * Queued calls will be dispatched after the configured debounce delay.
    * @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.
+   * @param call - The RPC call to cancel.
+   */
+  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

package/dist/transport.js

@@ -1,6 +1,9 @@
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { IRPCReader } from "./reader.js";
+import { IRPC_STORE } from "./store.js";
 import { IRPCCall } from "./call.js";
+import { onCleanup, uuid } from "@anchorlib/core";
 
 //#region src/transport.ts
 /**
@@ -8,10 +11,20 @@ import { IRPCCall } from "./call.js";
 * 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.
@@ -21,12 +34,13 @@ var IRPCTransport = class {
 	}
 	/**
 	* Initiates an RPC call with the given specification and arguments.
+	* @param reader - The reader instance to attach to the RPC call.
 	* @param spec - The RPC specification defining the method to call.
 	* @param args - An array of arguments to pass to the RPC method.
 	* @param config - Optional call configuration, including timeout, retry settings, and more.
 	* @returns A promise that resolves with the RPC response data or rejects with an error.
 	*/
-	call(spec, args, config) {
+	call(spec, args, config, reader = new IRPCReader(uuid())) {
 		const payload = {
 			name: spec.name,
 			args
@@ -40,8 +54,15 @@ var IRPCTransport = class {
 			maxRetries,
 			retryMode,
 			retryDelay
-		});
-		this.schedule(call);
+		}, reader);
+		if (spec.stream) {
+			this.dispatch([call]).finally(() => {}).catch((err) => IRPC_STORE.error(err, [{
+				id: call.id,
+				name: call.payload.name
+			}]));
+			return call.reader;
+		} else this.schedule(call);
+		onCleanup(() => this.close(call));
 		return call.reader;
 	}
 	/**
@@ -52,12 +73,16 @@ var IRPCTransport = class {
 	schedule(call) {
 		const { debounce } = this.config ?? {};
 		if (debounce === false) {
-			this.dispatch([call]).finally(() => {}).catch(() => {});
+			this.dispatch([call]).finally(() => {}).catch((err) => IRPC_STORE.error(err, [{
+				id: call.id,
+				name: call.payload.name
+			}]));
 			return;
 		}
 		const timeout = typeof debounce === "number" && !Number.isNaN(debounce) ? debounce : 0;
 		const dispatch = () => {
-			this.dispatch(Array.from(this.queue)).finally(() => {}).catch(() => {});
+			const pending = Array.from(this.queue);
+			this.dispatch(pending);
 			this.queue.clear();
 		};
 		if (!this.queue.size) if (timeout === 0) queueMicrotask(dispatch);
@@ -65,6 +90,22 @@ 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.
+	*/
+	close(call) {
+		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.

package/dist/types.d.ts

@@ -1,8 +1,11 @@
-import { IRPC_DATA_TYPE, IRPC_EVENT_TYPE, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
+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 { StateChange } from "@anchorlib/core";
+import { IRPCReader } from "./reader.js";
+import { AsyncValue, StateChange } from "@anchorlib/core";
 import { ZodArray, ZodBoolean, ZodNull, ZodNumber, ZodObject, ZodSafeParseResult, ZodString, ZodUndefined } from "zod/v4";
 
 //#region src/types.d.ts
@@ -20,7 +23,7 @@ type IRPCSpecStore = Map<string, IRPCSpec<IRPCInputs, IRPCOutput>>;
 type IRPCStatus = (typeof IRPC_STATUS)[keyof typeof IRPC_STATUS];
 type IRPCDataType = (typeof IRPC_DATA_TYPE)[keyof typeof IRPC_DATA_TYPE];
 type IRPCPacketType = (typeof IRPC_PACKET_TYPE)[keyof typeof IRPC_PACKET_TYPE];
-type IRPCEventType = (typeof IRPC_EVENT_TYPE)[keyof typeof IRPC_EVENT_TYPE];
+type IRPCBaseContext = (typeof IRPC_BASE_CONTEXT)[keyof typeof IRPC_BASE_CONTEXT];
 type IRPCPacketBase = {
   id: string;
   name: string;
@@ -29,10 +32,6 @@ type IRPCPacketBase = {
   createdAt?: number;
   arrivedAt?: number;
 };
-type IRPCPacketData = {
-  type: IRPCDataType;
-  value: IRPCData;
-};
 type IRPCPacketCall = IRPCPacketBase & {
   args: IRPCData[];
 };
@@ -52,6 +51,56 @@ interface IRPCReadable<T> {
   error: Error | undefined;
   status: IRPCStatus;
 }
+/**
+ * Represents a client-side stub for a remote function.
+ * When called, it returns an IRPCReader to handle the asynchronous result or stream.
+ *
+ * @template T - The original function type.
+ * @template A - The argument types of the function.
+ * @template R - The return data type.
+ */
+interface IRPCStub<T, A$1 extends unknown[], R$1 extends IRPCData> {
+  (...args: A$1): IRPCReader<R$1>;
+  stub: T;
+  /**
+   * Creates a call that expect to run in browser environment.
+   * The function runs immediately on the browser and will not re-run.
+   *
+   * @param args - A factory function returning the argument array.
+   * @returns An IRPCReader instance for handling the asynchronous result or stream.
+   */
+  once(...args: A$1): IRPCReader<R$1>;
+  /**
+   * Creates a reactive call that expect to run in browser environment.
+   * The function runs immediately on the browser and will re-run when
+   * the reactive dependencies change.
+   *
+   * @param args - A factory function returning the argument array.
+   * @param debounce - The debounce time in milliseconds.
+   * @returns An IRPCReader instance for handling the asynchronous result or stream.
+   */
+  with(args: () => A$1, debounce?: number): IRPCReader<R$1>;
+  /**
+   * Creates a reactive call that expect to run in browser environment.
+   * The function only runs on the first dependency change and re-run
+   * when the reactive dependencies change.
+   *
+   * @param args - A factory function returning the argument array.
+   * @param debounce - The debounce time in milliseconds.
+   * @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.
+ * It automatically unwraps RemoteState types to determine the underlying data type.
+ *
+ * @template T - The function type to be transformed.
+ */
+type IRPCFunction<T> = T extends ((...args: infer A) => infer R) ? R extends RemoteState<infer S> ? S extends IRPCData ? IRPCStub<T, A, S> : IRPCStub<T, A, IRPCData> : R extends Promise<infer O> ? O extends IRPCData ? IRPCStub<T, A, O> : IRPCStub<T, A, IRPCData> : R extends IRPCData ? IRPCStub<T, A, R> : IRPCStub<T, A, IRPCData> : IRPCStub<T, [], IRPCData>;
 /**
  * Represents primitive data types that can be used in IRPC communications.
  * Includes string, number, boolean, null, and undefined.
@@ -68,7 +117,7 @@ type IRPCObject = {
  * Represents all possible data types in IRPC, including primitives, objects, and arrays.
  * This is a recursive type that allows nested structures.
  */
-type IRPCData = IRPCPrimitive | IRPCObject | IRPCData[];
+type IRPCData = IRPCPrimitive | IRPCObject | IRPCFile | IRPCData[];
 /**
  * Union type of all primitive Zod schema types used for validation.
  */
@@ -123,11 +172,11 @@ type IRPCPayload = {
 /**
  * Defines the schema for input and output validation of an RPC function.
  */
-type IRPCSchema<I extends IRPCInputs, O extends IRPCOutput> = {
+type IRPCSchema<I extends IRPCInputs, O$1 extends IRPCOutput> = {
   /** Optional input validation schemas */
   input?: I;
   /** Optional output validation schema */
-  output?: O;
+  output?: O$1;
 };
 /**
  * Type definition for an RPC handler function.
@@ -141,13 +190,13 @@ type IRPCHandler = Function;
  * @template I - Tuple of input validation schemas
  * @template O - Output validation schema
  */
-type IRPCInit<I extends IRPCInputs, O extends IRPCOutput> = {
+type IRPCInit<R$1, I extends IRPCInputs, O$1 extends IRPCOutput> = {
   /** The name of the RPC function */
   name: string;
   /** Optional description of the RPC function */
   description?: string;
   /** Optional schema for input/output validation */
-  schema?: IRPCSchema<I, O>;
+  schema?: IRPCSchema<I, O$1>;
   /** Optional maximum age of a call in milliseconds */
   maxAge?: number;
   /**
@@ -157,7 +206,20 @@ type IRPCInit<I extends IRPCInputs, O extends IRPCOutput> = {
    * This can help reduce the number of actual function executions.
    */
   coalesce?: boolean;
+  /** Optional initialization function to seed the data */
+  init?: () => R$1;
 } & IRPCCallConfig;
+/**
+ * Configuration options for initializing an RPC stream function.
+ * Contains metadata and constraints for the RPC stream function.
+ *
+ * @template I - Tuple of input validation schemas
+ * @template O - Output validation schema
+ */
+type IRPCStreamInit<I extends IRPCInputs, O$1 extends IRPCOutput, R$1> = IRPCInit<R$1, I, O$1> & {
+  stream: true;
+  ttl?: number;
+};
 /**
  * Type definition for an RPC declaration.
  * Represents an RPC function with its name, description, and configuration.
@@ -166,9 +228,7 @@ type IRPCInit<I extends IRPCInputs, O extends IRPCOutput> = {
  * @template I - Tuple of input validation schemas
  * @template O - Output validation schema
  */
-type IRPCDeclareInit<F, I extends IRPCInputs, O extends IRPCOutput> = F extends ((...args: any[]) => RemoteState<infer R>) ? IRPCInit<I, IRPCOutput> & {
-  init: () => R;
-} : IRPCInit<I, O>;
+type IRPCDeclareInit<F, I extends IRPCInputs, O$1 extends IRPCOutput> = F extends ((...args: IRPCData[]) => infer R) ? R extends RemoteState<infer S> ? S extends IRPCData ? IRPCStreamInit<I, O$1, S> : IRPCInit<IRPCData, IRPCInputs, IRPCOutput> : R extends Promise<infer D> ? D extends IRPCData ? IRPCInit<D, I, O$1> : IRPCInit<IRPCData, IRPCInputs, IRPCOutput> : R extends IRPCData ? IRPCInit<R, I, O$1> : IRPCInit<IRPCData, IRPCInputs, IRPCOutput> : IRPCInit<IRPCData, IRPCInputs, IRPCOutput>;
 /**
  * Complete specification for an RPC function including its implementation.
  * Extends IRPCInit with the actual handler function.
@@ -176,9 +236,14 @@ type IRPCDeclareInit<F, I extends IRPCInputs, O extends IRPCOutput> = F extends
  * @template I - Tuple of input validation schemas
  * @template O - Output validation schema
  */
-type IRPCSpec<I extends IRPCInputs, O extends IRPCOutput> = IRPCInit<I, O> & {
+type IRPCSpec<I extends IRPCInputs, O$1 extends IRPCOutput> = IRPCInit<IRPCData, I, O$1> & {
+  /** Optional time-to-live for a call in milliseconds */
+  ttl?: number;
+  /** Whether to stream the result of the RPC call */
+  stream?: boolean;
   /** The actual handler function that implements the RPC */
   handler: IRPCHandler;
+  /** Optional initialization function for a stream RPC */
   init?: () => unknown;
 };
 /**
@@ -191,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;
@@ -238,6 +310,8 @@ type IRPCCallConfig = {
   retryMode?: 'linear' | 'exponential';
   /** Base delay between retries in milliseconds */
   retryDelay?: number;
+  /** Optional initialization function for a stream RPC */
+  init?: () => unknown;
 };
 /**
  * Configuration for transport layer, extending call configuration with debounce settings.
@@ -246,5 +320,17 @@ type TransportConfig = IRPCCallConfig & {
   /** Debounce setting for transport - can be a boolean to enable/disable or a number for specific delay */
   debounce?: number | boolean;
 };
+type StreamCleanup = () => void;
+/**
+ * A callback function type used to natively construct and drive a reactive stream.
+ * It provides the initial reactive data reference and terminal resolution hooks
+ * without forcing strict async/await boundaries, securely yielding stream operations.
+ *
+ * @template T - The type of data yielded globally by the stream.
+ * @param state - The reactive state reference for the stream.
+ * @param resolve - Callback to statically mark the stream as successfully completed, optionally with a resolved value.
+ * @param reject - Callback to forcefully throw a runtime error into the stream structure.
+ */
+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, IRPCData, IRPCDataSchema, IRPCDataType, IRPCDeclareInit, IRPCError, IRPCEventType, IRPCHandler, IRPCInit, IRPCInputs, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCPacketAnswer, IRPCPacketBase, IRPCPacketCall, IRPCPacketClose, IRPCPacketData, IRPCPacketEvent, IRPCPacketStream, IRPCPacketType, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCReadable, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStatus, IRPCStubStore, 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,18 +1,20 @@
 {
   "type": "module",
   "name": "@irpclib/irpc",
-  "version": "1.0.0-beta.22",
+  "version": "1.0.0-beta.24",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
     }
   },
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "directories": {
     "dist": "./dist"
   },
@@ -27,7 +29,7 @@
     "publint": "0.3.15",
     "rimraf": "6.0.1",
     "tsdown": "0.15.9",
-    "vite": "7.1.12",
+    "vite": "8.0.10",
     "vitest": "^3.2.4",
     "zod": "^4.1.5"
   },
@@ -48,6 +50,6 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@anchorlib/core": "^1.0.0-beta.22"
+    "@anchorlib/core": "^1.0.0-beta.24"
   }
-}
+}

package/readme.md

@@ -120,7 +120,7 @@ import { loadDashboard } from './index.js';
 import { stream } from '@irpclib/irpc';
 
 irpc.construct(loadDashboard, (userId) => {
-  return stream((data, resolve) => {
+  return stream(({ data }, resolve) => {
     const q1 = db.users.get(userId).then(res => data.user = res);
     const q2 = db.sales.aggregate(userId).then(res => data.sales = res);
     
@@ -131,6 +131,8 @@ irpc.construct(loadDashboard, (userId) => {
 
 ### 4. Setup Server
 
+The integration point extracts application-level values from transport-specific objects and injects them as standardized context via `initContext`. This keeps middleware and handlers transport-agnostic.
+
 ```typescript
 // server.ts
 import { setContextProvider } from '@irpclib/irpc';
@@ -147,7 +149,10 @@ Bun.serve({
   port: 3000,
   routes: {
     [transport.endpoint]: {
-      POST: (req) => router.resolve(req),
+      POST: (req) => router.resolve(req, [
+        ['token', req.headers.get('authorization')],
+        ['locale', req.headers.get('accept-language')],
+      ]),
     }
   },
 });
@@ -256,7 +261,7 @@ export const createUser = irpc.declare({
 
 ## Documentation
 
-For detailed documentation, visit [https://anchorlib.dev/docs/irpc](https://anchorlib.dev/docs/irpc)
+For detailed documentation, visit [https://airlib.dev/irpc](https://airlib.dev/irpc)
 
 ## License
 

package/dist/uuid.d.ts

@@ -1,21 +0,0 @@
-//#region src/uuid.d.ts
-/**
- * A function that generates a random UUID string.
- *
- * @returns A UUID v4 string in the format xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
- */
-type UUIDProvider = () => string;
-/**
- * Generates a new UUID using the currently configured provider.
- *
- * @returns A UUID string generated by the current provider
- */
-declare function uuid(): string;
-/**
- * Sets a custom UUID provider function to be used by the uuid() function.
- *
- * @param provider - A function that returns a UUID string when called
- */
-declare function setUUIDProvider(provider: UUIDProvider): void;
-//#endregion
-export { UUIDProvider, setUUIDProvider, uuid };