@peerbit/stream 5.1.3 → 5.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peerbit/stream",
-  "version": "5.1.3",
+  "version": "5.1.5",
   "description": "A building block for direct streaming protocols",
   "sideEffects": false,
   "type": "module",
@@ -96,11 +96,11 @@
     "uint8arraylist": "^2.4.8",
     "uint8arrays": "^5.1.0",
     "yallist": "^5.0.0",
+    "@peerbit/cache": "3.1.1",
     "@peerbit/crypto": "3.1.4",
-    "@peerbit/logger": "2.0.1",
-    "@peerbit/stream-interface": "6.0.13",
+    "@peerbit/stream-interface": "6.0.14",
     "@peerbit/time": "3.0.1",
-    "@peerbit/cache": "3.1.0"
+    "@peerbit/logger": "2.0.1"
   },
   "scripts": {
     "bench": "TS_NODE_PROJECT=../../../tsconfig.json node --loader ts-node/esm ./benchmark/index.ts",

package/src/index.ts

@@ -54,7 +54,11 @@ import {
 	getDeliveryHopTrace,
 	getResponsePriorityFromMessage,
 	hasDeliveryHop,
+	isAcknowledgeAnyWhereDeliveryMode,
+	isAcknowledgeDeliveryMode,
 	isAcknowledgedDeliveryMode,
+	isAnyWhereDeliveryMode,
+	isSilentDeliveryMode,
 	setDeliveryOriginHop,
 } from "@peerbit/stream-interface";
 import type {
@@ -126,6 +130,7 @@ export {
 	type RustDecodedFanoutUnicast,
 	type RustDecodedPubSubMessage,
 	type RustEagerBlockCache,
+	type RustEagerBlockCacheStats,
 	type RustFanoutTree,
 	type RustLanesInit,
 	type RustParentUpgradeGateOptions,
@@ -163,6 +168,17 @@ const markPromiseHandled = <T>(promise: Promise<T>): Promise<T> => {
 	return promise;
 };
 
+const closeRawStreamBestEffort = (stream: Stream): void => {
+	try {
+		// WebRTC close can reject later while waiting for FIN_ACK. These lifecycle
+		// paths are intentionally fire-and-forget, so observe the rejection without
+		// delaying pruning or shutdown.
+		void Promise.resolve(stream.close?.()).catch(() => {});
+	} catch {
+		// Closing discarded streams is best-effort, including synchronous failures.
+	}
+};
+
 const logError = (e?: any) => {
 	if (e?.message === "Cannot push value onto an ended pushable") {
 		return; // ignore since we are trying to push to a closed stream
@@ -478,7 +494,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 						await waitForDrain(raw, this.outboundAbortController.signal);
 					}
 				}
-				raw.close?.();
+				closeRawStreamBestEffort(raw);
 			} catch (err) {
 				candidate.aborted = true;
 				try {
@@ -518,12 +534,13 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 		if (this.outboundStreams.length <= 1) return;
 		if (reset && this._outboundPruneTimer) {
 			clearTimeout(this._outboundPruneTimer);
+			this._outboundPruneTimer = undefined;
 		}
 		if (!this._outboundPruneTimer) {
-			this._outboundPruneTimer = setTimeout(
-				() => this.pruneOutboundCandidates(),
-				PeerStreams.OUTBOUND_GRACE_MS,
-			);
+			this._outboundPruneTimer = setTimeout(() => {
+				this._outboundPruneTimer = undefined;
+				this.pruneOutboundCandidates();
+			}, PeerStreams.OUTBOUND_GRACE_MS);
 		}
 	}
 	constructor(init: PeerStreamsInit) {
@@ -692,9 +709,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 					try {
 						f.raw.abort?.(new AbortError("Failed write" as any));
 					} catch {}
-					try {
-						f.raw.close?.();
-					} catch {}
+					closeRawStreamBestEffort(f.raw);
 				}
 				// If more than one remains schedule prune; else ensure outbound event raised
 				if (this.outboundStreams.length > 1) this._scheduleOutboundPrune(true);
@@ -805,11 +820,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 			} catch {
 				logger.error("Failed to abort inbound stream");
 			}
-			try {
-				drop.raw.close?.();
-			} catch {
-				logger.error("Failed to close inbound stream");
-			}
+			closeRawStreamBestEffort(drop.raw);
 		}
 		const abortController = new AbortController();
 		const decoded = pipe(stream, (source) =>
@@ -868,9 +879,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 			try {
 				candidate.abortController.abort();
 			} catch {}
-			try {
-				candidate.raw.close?.();
-			} catch {}
+			closeRawStreamBestEffort(candidate.raw);
 		}
 		this.inboundStreams = survivors;
 		// update legacy references if they were pruned
@@ -903,7 +912,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 			try {
 				record.raw.abort?.(reason);
 			} catch {}
-			void Promise.resolve(record.raw.close?.()).catch(() => {});
+			closeRawStreamBestEffort(record.raw);
 		}
 		if (this.rawInboundStream === record.raw) {
 			const next = this.inboundStreams[0];
@@ -923,8 +932,9 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	 */
 
 	async attachOutboundStream(stream: Stream) {
-		if (this.outboundStreams[0] && stream.id === this.outboundStreams[0].raw.id)
+		if (this.outboundStreams.some((candidate) => candidate.raw === stream)) {
 			return; // duplicate
+		}
 		this._addOutboundCandidate(stream);
 		if (this.outboundStreams.length === 1) {
 			this.dispatchEvent(new CustomEvent("stream:outbound"));
@@ -971,11 +981,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 				} catch {
 					logger.error("Failed to close outbound pushable");
 				}
-				try {
-					c.raw.close?.();
-				} catch {
-					logger.error("Failed to close outbound stream");
-				}
+				closeRawStreamBestEffort(c.raw);
 			}
 			this.outboundStreams = [chosen];
 		} catch (e) {
@@ -1071,7 +1077,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 						} catch {
 							// ignore
 						}
-						void Promise.resolve(inbound.raw.close?.()).catch(() => {});
+						closeRawStreamBestEffort(inbound.raw);
 					} catch {
 						logger.error("Failed to close inbound stream");
 					}
@@ -2629,16 +2635,16 @@ export abstract class DirectStream<
 
 		let isForMe = false;
 		if (
-			message.header.mode instanceof AnyWhere ||
-			message.header.mode instanceof AcknowledgeAnyWhere
+			isAnyWhereDeliveryMode(message.header.mode) ||
+			isAcknowledgeAnyWhereDeliveryMode(message.header.mode)
 		) {
 			isForMe = true;
 		} else {
 			const isFromSelf = this.publicKey.equals(from);
 			if (
 				!isFromSelf &&
-				(message.header.mode instanceof SilentDelivery ||
-					message.header.mode instanceof AcknowledgeDelivery)
+				(isSilentDeliveryMode(message.header.mode) ||
+					isAcknowledgeDeliveryMode(message.header.mode))
 			) {
 				isForMe = message.header.mode.to.includes(this.publicKeyHash);
 			}
@@ -2663,8 +2669,8 @@ export abstract class DirectStream<
 		}
 
 		if (
-			message.header.mode instanceof SilentDelivery ||
-			message.header.mode instanceof AcknowledgeDelivery
+			isSilentDeliveryMode(message.header.mode) ||
+			isAcknowledgeDeliveryMode(message.header.mode)
 		) {
 			if (
 				message.header.mode.to &&
@@ -2679,8 +2685,8 @@ export abstract class DirectStream<
 			// Forward
 			const shouldForward =
 				seenBefore === 0 ||
-				((message.header.mode instanceof AcknowledgeDelivery ||
-					message.header.mode instanceof AcknowledgeAnyWhere) &&
+				((isAcknowledgeDeliveryMode(message.header.mode) ||
+					isAcknowledgeAnyWhereDeliveryMode(message.header.mode)) &&
 					seenBefore < message.header.mode.redundancy);
 
 			if (shouldForward) {
@@ -2712,14 +2718,12 @@ export abstract class DirectStream<
 		message: DataMessage | Goodbye,
 		seenBefore: number,
 	) {
-		if (
-			message.header.mode instanceof AcknowledgeDelivery ||
-			message.header.mode instanceof AcknowledgeAnyWhere
-		) {
+		if (isAcknowledgedDeliveryMode(message.header.mode)) {
 			const isRecipient =
-				message.header.mode instanceof AcknowledgeAnyWhere
-					? true
-					: message.header.mode.to.includes(this.publicKeyHash);
+				isAcknowledgeAnyWhereDeliveryMode(message.header.mode) ||
+				(message.header.mode as AcknowledgeDelivery).to.includes(
+					this.publicKeyHash,
+				);
 			const shouldAcknowledge = this.rustCore
 				? this.rustCore.decisions.shouldAcknowledge({
 						isRecipient,
@@ -2752,8 +2756,7 @@ export abstract class DirectStream<
 							// only include once (seenBefore=0) and only if we have not recently pruned
 							// a connection to any signer in the path
 							origin:
-								(message.header.mode instanceof AcknowledgeAnyWhere ||
-									message.header.mode instanceof AcknowledgeDelivery) &&
+								isAcknowledgedDeliveryMode(message.header.mode) &&
 								seenBefore === 0 &&
 								!signers.find((x) =>
 									this.prunedConnectionsCache?.has(x),
@@ -2974,8 +2977,8 @@ export abstract class DirectStream<
 				});
 
 		if (
-			mode instanceof AcknowledgeDelivery ||
-			mode instanceof SilentDelivery
+			isAcknowledgeDeliveryMode(mode) ||
+			isSilentDeliveryMode(mode)
 		) {
 			if (mode.to) {
 				let preLength = mode.to.length;
@@ -3168,7 +3171,7 @@ export abstract class DirectStream<
 		relayed?: boolean,
 		signal?: AbortSignal,
 	): Promise<{ promise: Promise<void>; startTimeout: () => void }> {
-		if (message.header.mode instanceof AnyWhere) {
+		if (isAnyWhereDeliveryMode(message.header.mode)) {
 			return {
 				promise: Promise.resolve(),
 				startTimeout: () => {},
@@ -3333,7 +3336,7 @@ export abstract class DirectStream<
 				) {
 					const shouldKeepCallbackForRouteLearning =
 						!relayed &&
-						message.header.mode instanceof AcknowledgeDelivery &&
+						isAcknowledgeDeliveryMode(message.header.mode) &&
 						message.header.mode.redundancy > 1;
 					if (haveReceivers && !shouldKeepCallbackForRouteLearning) {
 						// If we have an explicit recipient list we can clear the ACK callback once we
@@ -3368,8 +3371,7 @@ export abstract class DirectStream<
 				// This matters because relays may modify `to`, and because "ack-anywhere" style probes intentionally
 				// do not provide an explicit recipient list.
 				if (
-					message.header.mode instanceof AcknowledgeDelivery ||
-					message.header.mode instanceof AcknowledgeAnyWhere
+					isAcknowledgedDeliveryMode(message.header.mode)
 				) {
 					const upstreamHash = messageFrom?.publicKey.hashcode();
 
@@ -3453,7 +3455,7 @@ export abstract class DirectStream<
 			(!message.header.signatures ||
 				message.header.signatures.publicKeys.length === 0) &&
 			message instanceof DataMessage &&
-			message.header.mode instanceof SilentDelivery === false
+			!isSilentDeliveryMode(message.header.mode)
 		) {
 			throw new Error("Missing signature");
 		}
@@ -3464,8 +3466,7 @@ export abstract class DirectStream<
 
 		if (
 			(message instanceof DataMessage || message instanceof Goodbye) &&
-			(message.header.mode instanceof AcknowledgeDelivery ||
-				message.header.mode instanceof AcknowledgeAnyWhere)
+			isAcknowledgedDeliveryMode(message.header.mode)
 		) {
 			const deliveryDeferredPromise = await this.createDeliveryPromise(
 				from,
@@ -3491,8 +3492,8 @@ export abstract class DirectStream<
 
 			if (message instanceof DataMessage) {
 				if (
-					(message.header.mode instanceof AcknowledgeDelivery ||
-						message.header.mode instanceof SilentDelivery) &&
+					(isAcknowledgeDeliveryMode(message.header.mode) ||
+						isSilentDeliveryMode(message.header.mode)) &&
 					!to
 				) {
 					if (message.header.mode.to.length === 0) {
@@ -3517,7 +3518,7 @@ export abstract class DirectStream<
 						for (const [neighbour, _distantPeers] of fanout) {
 							const stream = this.peers.get(neighbour);
 							if (!stream) continue;
-							if (message.header.mode instanceof SilentDelivery) {
+							if (isSilentDeliveryMode(message.header.mode)) {
 								message.header.mode.to = [..._distantPeers.keys()];
 								promises.push(
 									this.waitForPeerWrite(
@@ -3539,7 +3540,7 @@ export abstract class DirectStream<
 							}
 							usedNeighbours.add(neighbour);
 						}
-						if (message.header.mode instanceof SilentDelivery) {
+						if (isSilentDeliveryMode(message.header.mode)) {
 							message.header.mode.to = originalTo;
 						}
 
@@ -3549,7 +3550,7 @@ export abstract class DirectStream<
 						// a separate delivery mode.
 						if (
 							!isRelayed &&
-							message.header.mode instanceof AcknowledgeDelivery &&
+							isAcknowledgeDeliveryMode(message.header.mode) &&
 							usedNeighbours.size < message.header.mode.redundancy
 						) {
 							if (this.rustCore) {
@@ -3599,7 +3600,7 @@ export abstract class DirectStream<
 					// - For acknowledged deliveries, fall through to flooding (route discovery / repair).
 					// - For silent deliveries, relays should not flood (prevents unnecessary fanout); origin may still flood.
 					//   We still allow direct neighbour delivery to explicit recipients (if connected).
-					if (isRelayed && message.header.mode instanceof SilentDelivery) {
+					if (isRelayed && isSilentDeliveryMode(message.header.mode)) {
 						const promises: Promise<any>[] = [];
 						const originalTo = message.header.mode.to;
 						const recipients = this.rustCore

package/src/rust-core.ts

@@ -112,15 +112,25 @@ export interface RustBlockProviderCache {
 	clear(): void;
 }
 
+export type RustEagerBlockCacheStats = {
+	entries: number;
+	bytes: number;
+	peakEntries: number;
+	peakBytes: number;
+	evictions: number;
+	expirations: number;
+};
+
 /**
  * Eager-block cache with native bookkeeping. Block bytes stay host-side;
  * the native index decides retention/eviction.
  */
 export interface RustEagerBlockCache {
-	add(cid: string, bytes: Uint8Array): void;
+	add(cid: string, bytes: Uint8Array): boolean;
 	get(cid: string): Uint8Array | undefined;
 	del(cid: string): void;
 	clear(): void;
+	stats(): RustEagerBlockCacheStats;
 }
 
 /**
@@ -150,7 +160,11 @@ export interface RustBlockExchange {
 		ttlMs: number;
 		maxProvidersPerCid: number;
 	}): RustBlockProviderCache;
-	createEagerCache(init: { max: number; ttl: number }): RustEagerBlockCache;
+	createEagerCache(init: {
+		maxEntries: number;
+		maxBytes: number;
+		ttlMs: number;
+	}): RustEagerBlockCache;
 }
 
 /**