@irpclib/irpc 1.2.0 → 1.2.2

package/dist/enum.d.ts

@@ -28,6 +28,7 @@ declare const IRPC_FILE_STATUS: {
   readonly IDLE: "idle";
   readonly PENDING: "pending";
   readonly SUCCESS: "success";
+  readonly ABORTED: "aborted";
   readonly ERROR: "error";
 };
 //#endregion

package/dist/enum.js

@@ -28,6 +28,7 @@ const IRPC_FILE_STATUS = {
 	IDLE: "idle",
 	PENDING: "pending",
 	SUCCESS: "success",
+	ABORTED: "aborted",
 	ERROR: "error"
 };
 

package/dist/file.d.ts

@@ -26,6 +26,33 @@ declare class IRPCFile {
   data: Blob;
   constructor(meta: IRPCFileMeta, data?: Blob);
 }
+declare class IRPCBlob {
+  url: string;
+  meta?: {
+    type?: string;
+    size?: number;
+    name?: string;
+  } | undefined;
+  protected state: IRPCFileState;
+  data: Blob;
+  private pipes;
+  private promise;
+  private controller?;
+  get status(): IRPCFileStatus;
+  get error(): Error | undefined;
+  get downloaded(): number;
+  get success(): boolean;
+  get completed(): boolean;
+  constructor(url: string, meta?: {
+    type?: string;
+    size?: number;
+    name?: string;
+  } | undefined);
+  load(): Promise<Blob>;
+  pipe(fn: IRPCFilePipe): IRPCFileUnpipe;
+  then<TResult1 = Blob, TResult2 = never>(onfulfilled?: ((value: Blob) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<Blob | TResult>;
+}
 declare class IRPCFileStream extends IRPCFile {
   private pipes;
   private buffer;
@@ -34,4 +61,4 @@ declare class IRPCFileStream extends IRPCFile {
   pipe(fn: IRPCFilePipe): IRPCFileUnpipe;
 }
 //#endregion
-export { IRPCFile, IRPCFileMeta, IRPCFilePipe, IRPCFileState, IRPCFileStatus, IRPCFileStream, IRPCFileUnpipe };
+export { IRPCBlob, IRPCFile, IRPCFileMeta, IRPCFilePipe, IRPCFileState, IRPCFileStatus, IRPCFileStream, IRPCFileUnpipe };

package/dist/file.js

@@ -1,6 +1,6 @@
-import { IRPC_FILE_STATUS } from "./enum.js";
+import { IRPC_FILE_STATUS, IRPC_STATUS } from "./enum.js";
 import { IRPC_STORE } from "./store.js";
-import { mutable } from "@anchorlib/core";
+import { mutable, onCleanup } from "@anchorlib/core";
 
 //#region src/file.ts
 var IRPCFile = class {
@@ -33,6 +33,92 @@ var IRPCFile = class {
 		this.state.status = data ? IRPC_FILE_STATUS.SUCCESS : IRPC_FILE_STATUS.PENDING;
 	}
 };
+var IRPCBlob = class {
+	state = mutable({
+		status: IRPC_FILE_STATUS.PENDING,
+		downloaded: 0
+	});
+	data;
+	pipes = /* @__PURE__ */ new Set();
+	promise;
+	controller;
+	get status() {
+		return this.state.status;
+	}
+	get error() {
+		return this.state.error;
+	}
+	get downloaded() {
+		return this.state.downloaded;
+	}
+	get success() {
+		return this.status === IRPC_FILE_STATUS.SUCCESS;
+	}
+	get completed() {
+		return [IRPC_FILE_STATUS.SUCCESS, IRPC_FILE_STATUS.ERROR].includes(this.status);
+	}
+	constructor(url, meta) {
+		this.url = url;
+		this.meta = meta;
+		this.data = new Blob([], { type: meta?.type ?? "" });
+	}
+	load() {
+		if (this.promise) return this.promise;
+		this.controller = new AbortController();
+		this.state.status = IRPC_FILE_STATUS.PENDING;
+		this.promise = fetch(this.url, { signal: this.controller.signal }).then(async (response) => {
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			if (response.body && this.meta?.size) {
+				const reader = response.body.getReader();
+				const chunks = [];
+				let downloaded = 0;
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					if (value) {
+						chunks.push(value);
+						downloaded += value.byteLength;
+						this.state.downloaded = downloaded;
+						this.pipes.forEach((fn) => {
+							try {
+								fn(value);
+							} catch (error) {
+								IRPC_STORE.error(error, [{ url: this.url }]);
+							}
+						});
+					}
+				}
+				this.data = new Blob(chunks, { type: this.meta?.type ?? "" });
+			} else {
+				this.data = await response.blob();
+				this.state.downloaded = this.data.size;
+			}
+			this.state.status = IRPC_FILE_STATUS.SUCCESS;
+			return this.data;
+		}).catch((error) => {
+			IRPC_STORE.error(error, [{ url: this.url }]);
+			this.state.error = error;
+			/* v8 ignore next */
+			this.state.status = this.controller?.signal?.aborted ? IRPC_STATUS.ABORTED : IRPC_FILE_STATUS.ERROR;
+			throw error;
+		});
+		onCleanup(() => {
+			/* v8 ignore next */
+			this.controller?.abort();
+		});
+		return this.promise;
+	}
+	pipe(fn) {
+		this.pipes.add(fn);
+		return () => this.pipes.delete(fn);
+	}
+	then(onfulfilled, onrejected) {
+		return this.load().then(onfulfilled, onrejected);
+	}
+	catch(onrejected) {
+		return this.load().catch(onrejected);
+	}
+};
 var IRPCFileStream = class extends IRPCFile {
 	pipes = /* @__PURE__ */ new Set();
 	buffer;
@@ -83,4 +169,4 @@ var IRPCFileStream = class extends IRPCFile {
 };
 
 //#endregion
-export { IRPCFile, IRPCFileStream };
+export { IRPCBlob, IRPCFile, IRPCFileStream };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 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 { IRPCBlob, IRPCFile, IRPCFileMeta, IRPCFilePipe, IRPCFileState, IRPCFileStatus, IRPCFileStream, IRPCFileUnpipe } from "./file.js";
+import { IRPCBlobPointer, IRPCFilePointer, IRPCFileQueue, IRPCPacketJson, IRPCPacketQueues, IRPC_BLOB_IDENTIFIER, IRPC_FILE_IDENTIFIER, PacketStream, decode, decodeBlobs, encode, encodeBlobs, isBlobPointer, isFilePointer } from "./packet.js";
 import { DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, IRPCCall } from "./call.js";
 import { IRPCTransport } from "./transport.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";
@@ -17,4 +17,4 @@ 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, 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 };
+export { CALL_ERROR, CRUD_ERROR, CallError, CrudError, DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCAdapter, IRPCArraySchema, IRPCBlob, IRPCBlobPointer, 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_BLOB_IDENTIFIER, 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, decodeBlobs, encode, encodeBlobs, getAbortController, getAbortSignal, getContext, getCredentials, intercept, isBlobPointer, isFilePointer, plan, setContext, setContextProvider, stream, withContext };

package/dist/index.js

@@ -8,14 +8,14 @@ import { IRPCReader } from "./reader.js";
 import { IRPCTransport } from "./transport.js";
 import { IRPCPackage, createPackage, intercept } from "./module.js";
 import { IRPCRouter } from "./router.js";
+import { IRPCBlob, IRPCFile, IRPCFileStream } from "./file.js";
+import { IRPC_BLOB_IDENTIFIER, IRPC_FILE_IDENTIFIER, decode, decodeBlobs, encode, encodeBlobs, isBlobPointer, isFilePointer } from "./packet.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 { IRPCDriver } from "./types.js";
 import { plan } from "@anchorlib/core";
 
-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 };
+export { CALL_ERROR, CRUD_ERROR, CallError, CrudError, DEFAULT_RETRY_DELAY, DEFAULT_RETRY_MODE, HANDLER_ERROR, HOOK_ERROR, HandlerError, HookError, IRPCAdapter, IRPCBlob, IRPCCacher, IRPCCall, IRPCDriver, IRPCError, IRPCFile, IRPCFileStream, IRPCPackage, IRPCReader, IRPCResolver, IRPCRouter, IRPCStore, IRPCStream, IRPCTransport, IRPC_BASE_CONTEXT, IRPC_BLOB_IDENTIFIER, 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, decodeBlobs, encode, encodeBlobs, getAbortController, getAbortSignal, getContext, getCredentials, intercept, isBlobPointer, isFilePointer, plan, setContext, setContextProvider, stream, withContext };

package/dist/module.js

@@ -132,7 +132,7 @@ var IRPCPackage = class {
 		* @returns {IRPCReader<IRPCData>} - The reader for the call.
 		*/
 		function prepare(getArgs, deferred, debounce = 0) {
-			const reader = new IRPCReader(uuid(), spec.seed(), deferred ? IRPC_STATUS.IDLE : IRPC_STATUS.PENDING);
+			const reader = new IRPCReader(uuid(), spec.seed(), deferred ? IRPC_STATUS.IDLE : IRPC_STATUS.PENDING, true);
 			if (isBrowser()) {
 				const observer = createObserver(() => {
 					observer.reset();
@@ -143,6 +143,8 @@ var IRPCPackage = class {
 					const args = observer.run(getArgs);
 					if (!coalesce) return execute(args, reader);
 					schedule(() => {
+						if (reader.status === IRPC_STATUS.PENDING) reader.close();
+						reader.resume();
 						execute(args, reader);
 					});
 				};

package/dist/packet.d.ts

@@ -3,11 +3,21 @@ import { IRPCData } from "./types.js";
 
 //#region src/packet.d.ts
 declare const IRPC_FILE_IDENTIFIER: "IRPC_PACKET_FILE";
+declare const IRPC_BLOB_IDENTIFIER: "IRPC_PACKET_BLOB";
 type IRPCFilePointer = {
   id: string;
   type: typeof IRPC_FILE_IDENTIFIER;
   meta: IRPCFileMeta;
 };
+type IRPCBlobPointer = {
+  type: typeof IRPC_BLOB_IDENTIFIER;
+  url: string;
+  meta?: {
+    type?: string;
+    size?: number;
+    name?: string;
+  };
+};
 type IRPCFileQueue = {
   file: IRPCFilePointer;
   data: Blob;
@@ -26,7 +36,25 @@ type PacketStream = {
   resolved: number;
 };
 declare function isFilePointer(data: IRPCData): boolean;
+declare function isBlobPointer(data: IRPCData): boolean;
 declare function encode(data: IRPCData): IRPCPacketQueues;
 declare function decode(packet: IRPCPacketJson): PacketStream;
+/**
+ * Recursively replaces all IRPCBlobPointer objects in a data tree with IRPCBlob instances.
+ * Used by client-side transports to materialize blob references after receiving response data.
+ * Eagerly calls .load() to kick off the fetch — the caller awaits the thenable to get the loaded blob.
+ *
+ * @param data - The data tree potentially containing IRPCBlobPointer objects.
+ * @returns The data tree with blob pointers replaced by IRPCBlob instances.
+ */
+declare function decodeBlobs<T>(data: unknown): T;
+/**
+ * Recursively replaces all IRPCBlob instances in a data tree with IRPCBlobPointer objects.
+ * Used by IRPCStream to encode blobs before packets are JSON-serialized for transport.
+ *
+ * @param data - The data tree potentially containing IRPCBlob instances.
+ * @returns A new data tree with IRPCBlob instances replaced by IRPCBlobPointer objects.
+ */
+declare function encodeBlobs(data: unknown): unknown;
 //#endregion
-export { IRPCFilePointer, IRPCFileQueue, IRPCPacketJson, IRPCPacketQueues, IRPC_FILE_IDENTIFIER, PacketStream, decode, encode, isFilePointer };
+export { IRPCBlobPointer, IRPCFilePointer, IRPCFileQueue, IRPCPacketJson, IRPCPacketQueues, IRPC_BLOB_IDENTIFIER, IRPC_FILE_IDENTIFIER, PacketStream, decode, decodeBlobs, encode, encodeBlobs, isBlobPointer, isFilePointer };

package/dist/packet.js

@@ -1,11 +1,15 @@
-import { IRPCFile, IRPCFileStream } from "./file.js";
+import { IRPCBlob, IRPCFile, IRPCFileStream } from "./file.js";
 import { isArray, isObject, uuid } from "@anchorlib/core";
 
 //#region src/packet.ts
 const IRPC_FILE_IDENTIFIER = "IRPC_PACKET_FILE";
+const IRPC_BLOB_IDENTIFIER = "IRPC_PACKET_BLOB";
 function isFilePointer(data) {
 	return isObject(data) && data.type === IRPC_FILE_IDENTIFIER;
 }
+function isBlobPointer(data) {
+	return isObject(data) && data.type === IRPC_BLOB_IDENTIFIER;
+}
 function encode(data) {
 	const json = {
 		data,
@@ -15,7 +19,8 @@ function encode(data) {
 		json,
 		queues: []
 	};
-	if (data instanceof IRPCFile) {
+	if (data instanceof IRPCBlob) json.data = createBlobPointer(data);
+	else if (data instanceof IRPCFile) {
 		const { pointer, queue } = createPointer(data);
 		json.data = pointer;
 		json.files.push(pointer);
@@ -52,6 +57,13 @@ function createPointer(file) {
 		}
 	};
 }
+function createBlobPointer(blob) {
+	return {
+		type: IRPC_BLOB_IDENTIFIER,
+		url: blob.url,
+		meta: blob.meta
+	};
+}
 /**
 * Replace all IRPCFile inside an object with IRPCPacketFile.
 * @param {Record<string, unknown> | unknown[]} data - The object to encode.
@@ -60,7 +72,8 @@ function createPointer(file) {
 */
 function encodePointers(data, pointers, queues) {
 	if (isArray(data)) data.forEach((item, i) => {
-		if (item instanceof IRPCFile) {
+		if (item instanceof IRPCBlob) data[i] = createBlobPointer(item);
+		else if (item instanceof IRPCFile) {
 			const { pointer, queue } = createPointer(item);
 			data[i] = pointer;
 			pointers.push(pointer);
@@ -68,7 +81,8 @@ function encodePointers(data, pointers, queues) {
 		} else if (isObject(item) || isArray(item)) encodePointers(item, pointers, queues);
 	});
 	else if (isObject(data)) Object.entries(data).forEach(([key, value]) => {
-		if (value instanceof IRPCFile) {
+		if (value instanceof IRPCBlob) data[key] = createBlobPointer(value);
+		else if (value instanceof IRPCFile) {
 			const { pointer, queue } = createPointer(value);
 			data[key] = pointer;
 			pointers.push(pointer);
@@ -95,6 +109,41 @@ function decodePointers(data, files) {
 		} else if (isObject(value) || isArray(value)) decodePointers(value, files);
 	});
 }
+/**
+* Recursively replaces all IRPCBlobPointer objects in a data tree with IRPCBlob instances.
+* Used by client-side transports to materialize blob references after receiving response data.
+* Eagerly calls .load() to kick off the fetch — the caller awaits the thenable to get the loaded blob.
+*
+* @param data - The data tree potentially containing IRPCBlobPointer objects.
+* @returns The data tree with blob pointers replaced by IRPCBlob instances.
+*/
+function decodeBlobs(data) {
+	if (!data || typeof data !== "object") return data;
+	if (isBlobPointer(data)) {
+		const pointer = data;
+		const blob = new IRPCBlob(pointer.url, pointer.meta);
+		blob.load();
+		return blob;
+	}
+	if (Array.isArray(data)) for (let i = 0; i < data.length; i++) data[i] = decodeBlobs(data[i]);
+	else for (const [key, value] of Object.entries(data)) data[key] = decodeBlobs(value);
+	return data;
+}
+/**
+* Recursively replaces all IRPCBlob instances in a data tree with IRPCBlobPointer objects.
+* Used by IRPCStream to encode blobs before packets are JSON-serialized for transport.
+*
+* @param data - The data tree potentially containing IRPCBlob instances.
+* @returns A new data tree with IRPCBlob instances replaced by IRPCBlobPointer objects.
+*/
+function encodeBlobs(data) {
+	if (data instanceof IRPCBlob) return createBlobPointer(data);
+	if (!data || typeof data !== "object") return data;
+	if (Array.isArray(data)) return data.map((item) => encodeBlobs(item));
+	const result = {};
+	for (const [key, value] of Object.entries(data)) result[key] = encodeBlobs(value);
+	return result;
+}
 
 //#endregion
-export { IRPC_FILE_IDENTIFIER, decode, encode, isFilePointer };
+export { IRPC_BLOB_IDENTIFIER, IRPC_FILE_IDENTIFIER, decode, decodeBlobs, encode, encodeBlobs, isBlobPointer, isFilePointer };

package/dist/stream.js

@@ -2,6 +2,7 @@ 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 { encodeBlobs } from "./packet.js";
 import { IRPC_STORE } from "./store.js";
 
 //#region src/stream.ts
@@ -65,7 +66,7 @@ var IRPCStream = class {
 			}
 			const { result } = response;
 			if (result instanceof RemoteState) {
-				this.value = result.data;
+				this.value = encodeBlobs(result.data);
 				if (result.status === IRPC_STATUS.SUCCESS || result.status === IRPC_STATUS.ERROR) {
 					if (result.status === IRPC_STATUS.ERROR) {
 						this.error = HandlerError.failed(result.error).json();
@@ -90,7 +91,7 @@ var IRPCStream = class {
 						id,
 						name,
 						type: IRPC_PACKET_TYPE.ANSWER,
-						data: result.data,
+						data: encodeBlobs(result.data),
 						status: result.status,
 						createdAt: Date.now()
 					});
@@ -105,7 +106,7 @@ var IRPCStream = class {
 							data: {
 								type,
 								keys,
-								value
+								value: encodeBlobs(value)
 							},
 							type: IRPC_PACKET_TYPE.EVENT,
 							status: state.status,
@@ -140,7 +141,7 @@ var IRPCStream = class {
 				};
 				abortSignal?.addEventListener("abort", abortStream, { once: true });
 			} else {
-				this.value = result;
+				this.value = encodeBlobs(result);
 				if (response.error) {
 					this.error = response.error;
 					this.status = IRPC_STATUS.ERROR;

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
-import { IRPCFile } from "./file.js";
+import { IRPCBlob, IRPCFile } from "./file.js";
 import { IRPCFilePointer } from "./packet.js";
 import { IRPCTransport } from "./transport.js";
 import { RemoteState } from "./state.js";
@@ -114,12 +114,12 @@ 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 | IRPCFile | IRPCData[];
+type IRPCData = IRPCPrimitive | IRPCObject | IRPCFile | IRPCBlob | IRPCData[];
 /**
  * Represents all possible defined data types in IRPC, including primitives, objects, and arrays.
  * This is a recursive type that allows nested structures.
  */
-type IRPCDefined = string | number | boolean | IRPCObject | IRPCFile | IRPCDefined[];
+type IRPCDefined = string | number | boolean | IRPCObject | IRPCFile | IRPCBlob | IRPCDefined[];
 /**
  * Union type of all primitive Zod schema types used for validation.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@irpclib/irpc",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
   "exports": {
@@ -36,7 +36,7 @@
     "zod": "^4.1.5"
   },
   "peerDependencies": {
-    "@anchorlib/core": "1.2.0",
+    "@anchorlib/core": "1.2.2",
     "typescript": "^5.9.3"
   },
   "optionalDependencies": {