@peerbit/stream 4.3.10 → 4.4.0

package/src/index.ts

@@ -23,13 +23,13 @@ import { Circuit } from "@multiformats/multiaddr-matcher";
 import { Cache } from "@peerbit/cache";
 import {
 	PublicSignKey,
-	type SignatureWithKey,
 	getKeypairFromPrivateKey,
 	getPublicKeyFromPeerId,
 	ready,
 	sha256Base64,
 	toBase64,
 } from "@peerbit/crypto";
+import type { SignatureWithKey } from "@peerbit/crypto";
 import {
 	ACK,
 	AcknowledgeDelivery,
@@ -37,25 +37,27 @@ import {
 	DataMessage,
 	DeliveryError,
 	Goodbye,
-	type IdOptions,
 	InvalidMessageError,
 	Message,
 	MessageHeader,
 	MultiAddrinfo,
 	NotStartedError,
-	type PriorityOptions,
-	type PublicKeyFromHashResolver,
 	SeekDelivery,
 	SilentDelivery,
-	type StreamEvents,
 	TracedDelivery,
-	type WaitForPeer,
-	type WithExtraSigners,
-	type WithMode,
-	type WithTo,
 	deliveryModeHasReceiver,
 	getMsgId,
 } from "@peerbit/stream-interface";
+import type {
+	IdOptions,
+	PriorityOptions,
+	PublicKeyFromHashResolver,
+	StreamEvents,
+	WaitForPeer,
+	WithExtraSigners,
+	WithMode,
+	WithTo,
+} from "@peerbit/stream-interface";
 import { AbortError, TimeoutError, delay } from "@peerbit/time";
 import { abortableSource } from "abortable-iterator";
 import * as lp from "it-length-prefixed";
@@ -86,7 +88,7 @@ export const dontThrowIfDeliveryError = (e: any) => {
 	throw e;
 };
 
-const logError = (e?: { message: string }) => {
+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
 	}
@@ -134,6 +136,41 @@ const getLaneFromPriority = (priority: number) => {
 	}
 	return 1;
 };
+interface OutboundCandidate {
+	raw: Stream;
+	pushable: PushableLanes<Uint8Array>;
+	created: number;
+	bytesDelivered: number;
+	aborted: boolean;
+	existing: boolean;
+}
+export interface InboundStreamRecord {
+	raw: Stream;
+	iterable: AsyncIterable<Uint8ArrayList>;
+	abortController: AbortController;
+	created: number;
+	lastActivity: number;
+	bytesReceived: number;
+}
+// Hook for tests to override queued length measurement (peerStreams, default impl)
+export let measureOutboundQueuedBytes: (
+	ps: PeerStreams, // return queued bytes for active outbound (lane 0) or 0 if none
+) => number = (ps: PeerStreams) => {
+	const active = ps._getActiveOutboundPushable();
+	if (!active) return 0;
+	// Prefer lane-aware helper if present
+	// @ts-ignore - optional test helper
+	if (typeof active.getReadableLength === "function") {
+		try {
+			// lane 0 only
+			return active.getReadableLength(0) || 0;
+		} catch {
+			// ignore
+		}
+	}
+	// @ts-ignore fallback for vanilla pushable
+	return active.readableLength || 0;
+};
 /**
  * Thin wrapper around a peer's inbound / outbound pubsub streams
  */
@@ -141,27 +178,24 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	public readonly peerId: PeerId;
 	public readonly publicKey: PublicSignKey;
 	public readonly protocol: string;
-	/**
-	 * Write stream - it's preferable to use the write method
-	 */
-	public outboundStream?: PushableLanes<Uint8Array>;
+	// Removed dedicated outboundStream; first element of outboundStreams[] is active
 
 	/**
-	 * Read stream
+	 * Backwards compatible single inbound references (points to first inbound candidate)
 	 */
 	public inboundStream?: AsyncIterable<Uint8ArrayList>;
-	/**
-	 * The raw outbound stream, as retrieved from conn.newStream
-	 */
-	public rawOutboundStream?: Stream;
-	/**
-	 * The raw inbound stream, as retrieved from the callback from libp2p.handle
-	 */
 	public rawInboundStream?: Stream;
+
 	/**
-	 * An AbortController for controlled shutdown of the  treams
+	 * Multiple inbound stream support (more permissive than outbound)
+	 * We retain concurrent inbound streams to avoid races during migration; inactive ones can later be pruned.
 	 */
-	private inboundAbortController: AbortController;
+	public inboundStreams: InboundStreamRecord[] = [];
+
+	private _inboundPruneTimer?: ReturnType<typeof setTimeout>;
+	public static INBOUND_IDLE_MS = 10_000; // configurable grace for inactivity (made public for tests)
+	static MAX_INBOUND_STREAMS = 8; // sensible default to prevent flood
+
 	private outboundAbortController: AbortController;
 
 	private closed: boolean;
@@ -171,13 +205,92 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	public seekedOnce: boolean;
 
 	private usedBandWidthTracker: BandwidthTracker;
+
+	// Unified outbound streams list (during grace may contain >1; after pruning length==1)
+	private outboundStreams: OutboundCandidate[] = [];
+	// Public debug exposure of current raw outbound streams (during grace may contain >1)
+	public get rawOutboundStreams(): Stream[] {
+		return this.outboundStreams.map((c) => c.raw);
+	}
+	public _getActiveOutboundPushable(): PushableLanes<Uint8Array> | undefined {
+		return this.outboundStreams[0]?.pushable;
+	}
+	public _getOutboundCount() {
+		return this.outboundStreams.length;
+	}
+
+	public _getInboundCount() {
+		return this.inboundStreams.length;
+	}
+
+	public _debugInboundStats(): {
+		id: string;
+		created: number;
+		lastActivity: number;
+		bytesReceived: number;
+	}[] {
+		return this.inboundStreams.map((c) => ({
+			id: c.raw.id,
+			created: c.created,
+			lastActivity: c.lastActivity,
+			bytesReceived: c.bytesReceived,
+		}));
+	}
+	private _outboundPruneTimer?: ReturnType<typeof setTimeout>;
+	private static readonly OUTBOUND_GRACE_MS = 500; // TODO configurable
+
+	private _addOutboundCandidate(raw: Stream): OutboundCandidate {
+		const existing = this.outboundStreams.find((c) => c.raw === raw);
+		if (existing) return existing;
+		const pushableInst = pushableLanes<Uint8Array>({
+			lanes: 2,
+			onPush: (val: Uint8Array) => {
+				candidate.bytesDelivered += val.length || val.byteLength || 0;
+			},
+		});
+		const candidate: OutboundCandidate = {
+			raw,
+			pushable: pushableInst,
+			created: Date.now(),
+			bytesDelivered: 0,
+			aborted: false,
+			existing: false,
+		};
+		pipe(
+			pushableInst,
+			(source) => lp.encode(source, { maxDataLength: MAX_DATA_LENGTH_OUT }),
+			raw,
+		).catch((e: any) => {
+			candidate.aborted = true;
+			logError(e as { message: string } as any);
+		});
+		this.outboundStreams.push(candidate);
+		const origAbort = raw.abort?.bind(raw);
+		raw.abort = (err?: any) => {
+			candidate.aborted = true;
+			return origAbort?.(err);
+		};
+		return candidate;
+	}
+
+	private _scheduleOutboundPrune(reset = true) {
+		if (this.outboundStreams.length <= 1) return;
+		if (reset && this._outboundPruneTimer) {
+			clearTimeout(this._outboundPruneTimer);
+		}
+		if (!this._outboundPruneTimer) {
+			this._outboundPruneTimer = setTimeout(
+				() => this.pruneOutboundCandidates(),
+				PeerStreams.OUTBOUND_GRACE_MS,
+			);
+		}
+	}
 	constructor(init: PeerStreamsInit) {
 		super();
 
 		this.peerId = init.peerId;
 		this.publicKey = init.publicKey;
 		this.protocol = init.protocol;
-		this.inboundAbortController = new AbortController();
 		this.outboundAbortController = new AbortController();
 
 		this.closed = false;
@@ -190,14 +303,14 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	 * Do we have a connection to read from?
 	 */
 	get isReadable() {
-		return Boolean(this.inboundStream);
+		return this.inboundStreams.length > 0;
 	}
 
 	/**
 	 * Do we have a connection to write on?
 	 */
 	get isWritable() {
-		return Boolean(this.outboundStream);
+		return this.outboundStreams.length > 0;
 	}
 
 	get usedBandwidth() {
@@ -216,19 +329,62 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 				} mb`,
 			);
 		}
-		if (this.outboundStream == null) {
+		if (!this.isWritable) {
 			logger.error("No writable connection to " + this.peerId.toString());
 			throw new Error("No writable connection to " + this.peerId.toString());
 		}
 
 		this.usedBandWidthTracker.add(data.byteLength);
 
-		this.outboundStream.push(
-			data instanceof Uint8Array ? data : data.subarray(),
-			this.outboundStream.getReadableLength(0) === 0
-				? 0
-				: getLaneFromPriority(priority), // TODO use more lanes
-		);
+		// Write to all current outbound streams (normally 1, but >1 during grace)
+		const payload = data instanceof Uint8Array ? data : data.subarray();
+		let successes = 0;
+		let failures: any[] = [];
+		const failed: OutboundCandidate[] = [];
+		for (const c of this.outboundStreams) {
+			try {
+				c.pushable.push(
+					payload,
+					c.pushable.getReadableLength(0) === 0
+						? 0
+						: getLaneFromPriority(priority),
+				);
+				successes++;
+			} catch (e) {
+				failures.push(e);
+				failed.push(c);
+				logError(e);
+			}
+		}
+		if (successes === 0) {
+			throw new Error(
+				"All outbound writes failed (" +
+					failures.map((f) => f?.message).join(", ") +
+					")",
+			);
+		}
+		if (failures.length > 0) {
+			logger.warn(
+				`Partial outbound write failure: ${failures.length} failed, ${successes} succeeded`,
+			);
+			// Remove failed streams immediately (best-effort)
+			if (failed.length) {
+				this.outboundStreams = this.outboundStreams.filter(
+					(c) => !failed.includes(c),
+				);
+				for (const f of failed) {
+					try {
+						f.raw.abort?.(new AbortError("Failed write" as any));
+					} catch {}
+					try {
+						f.raw.close?.();
+					} catch {}
+				}
+				// If more than one remains schedule prune; else ensure outbound event raised
+				if (this.outboundStreams.length > 1) this._scheduleOutboundPrune(true);
+				else this.dispatchEvent(new CustomEvent("stream:outbound"));
+			}
+		}
 	}
 
 	/**
@@ -296,41 +452,108 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	/**
 	 * Attach a raw inbound stream and setup a read stream
 	 */
-	attachInboundStream(stream: Stream) {
-		// Create and attach a new inbound stream
-		// The inbound stream is:
-		// - abortable, set to only return on abort, rather than throw
-		// - transformed with length-prefix transform
-		this.rawInboundStream = stream;
-		this.inboundStream = abortableSource(
-			pipe(this.rawInboundStream, (source) =>
-				lp.decode(source, { maxDataLength: MAX_DATA_LENGTH_IN }),
-			),
-			this.inboundAbortController.signal,
-			{
-				returnOnAbort: true,
-				onReturnError: (err) => {
-					logger.error("Inbound stream error", err?.message);
-				},
-			},
+	attachInboundStream(stream: Stream): InboundStreamRecord {
+		// Support multiple concurrent inbound streams with inactivity pruning.
+		// Enforce max inbound streams (drop least recently active)
+		if (this.inboundStreams.length >= PeerStreams.MAX_INBOUND_STREAMS) {
+			let dropIndex = 0;
+			for (let i = 1; i < this.inboundStreams.length; i++) {
+				const a = this.inboundStreams[i];
+				const b = this.inboundStreams[dropIndex];
+				if (
+					a.lastActivity < b.lastActivity ||
+					(a.lastActivity === b.lastActivity && a.created < b.created)
+				) {
+					dropIndex = i;
+				}
+			}
+			const [drop] = this.inboundStreams.splice(dropIndex, 1);
+			try {
+				drop.abortController.abort();
+			} catch {
+				logger.error("Failed to abort inbound stream");
+			}
+			try {
+				drop.raw.close?.();
+			} catch {
+				logger.error("Failed to close inbound stream");
+			}
+		}
+		const abortController = new AbortController();
+		const decoded = pipe(stream, (source) =>
+			lp.decode(source, { maxDataLength: MAX_DATA_LENGTH_IN }),
 		);
+		const iterable = abortableSource(decoded, abortController.signal, {
+			returnOnAbort: true,
+			onReturnError: (err) => {
+				logger.error("Inbound stream error", err?.message);
+			},
+		});
+		const record: InboundStreamRecord = {
+			raw: stream,
+			iterable,
+			abortController,
+			created: Date.now(),
+			lastActivity: Date.now(),
+			bytesReceived: 0,
+		};
+		this.inboundStreams.push(record);
+		this._scheduleInboundPrune();
+		// Backwards compatibility: keep first inbound as public properties
+		if (this.inboundStreams.length === 1) {
+			this.rawInboundStream = stream;
+			this.inboundStream = iterable;
+		}
+		this.dispatchEvent(new CustomEvent("stream:inbound"));
+		return record;
+	}
 
-		/* this.rawInboundStream = stream
-		this.inboundAbortController = new AbortController()
-		this.inboundAbortController.signal.addEventListener('abort', () => {
-			this.rawInboundStream!.close()
-				.catch(err => {
-					this.rawInboundStream?.abort(err)
-				})
-		})
+	private _scheduleInboundPrune() {
+		if (this._inboundPruneTimer) return; // already scheduled
+		this._inboundPruneTimer = setTimeout(() => {
+			this._inboundPruneTimer = undefined;
+			this._pruneInboundInactive();
+			if (this.inboundStreams.length > 1) {
+				// schedule again if still multiple
+				this._scheduleInboundPrune();
+			}
+		}, PeerStreams.INBOUND_IDLE_MS);
+	}
 
-		this.inboundStream = pipe(
-			this.rawInboundStream!,
-			(source) => lp.decode(source, { maxDataLength: MAX_DATA_LENGTH_IN }),
-		)
- */
-		this.dispatchEvent(new CustomEvent("stream:inbound"));
-		return this.inboundStream;
+	private _pruneInboundInactive() {
+		if (this.inboundStreams.length <= 1) return;
+		const now = Date.now();
+		// Keep at least one (the most recently active)
+		this.inboundStreams.sort((a, b) => b.lastActivity - a.lastActivity);
+		const keep = this.inboundStreams[0];
+		const survivors: typeof this.inboundStreams = [keep];
+		for (let i = 1; i < this.inboundStreams.length; i++) {
+			const candidate = this.inboundStreams[i];
+			if (now - candidate.lastActivity <= PeerStreams.INBOUND_IDLE_MS) {
+				survivors.push(candidate);
+				continue; // still active
+			}
+			try {
+				candidate.abortController.abort();
+			} catch {}
+			try {
+				candidate.raw.close?.();
+			} catch {}
+		}
+		this.inboundStreams = survivors;
+		// update legacy references if they were pruned
+		if (!this.inboundStreams.includes(keep)) {
+			this.rawInboundStream = this.inboundStreams[0]?.raw;
+			this.inboundStream = this.inboundStreams[0]?.iterable;
+		}
+	}
+
+	public forcePruneInbound() {
+		if (this._inboundPruneTimer) {
+			clearTimeout(this._inboundPruneTimer);
+			this._inboundPruneTimer = undefined;
+		}
+		this._pruneInboundInactive();
 	}
 
 	/**
@@ -338,39 +561,111 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	 */
 
 	async attachOutboundStream(stream: Stream) {
-		// If an outbound stream already exists and is active, ignore the new one; if a raw stream exists, close it to avoid leaks
-		if (
-			this.outboundStream != null &&
-			stream.id !== this.rawOutboundStream?.id
-		) {
-			logger.info(
-				`Outbound stream already exists for ${this.peerId.toString()}, ignoring additional stream`,
+		if (this.outboundStreams[0] && stream.id === this.outboundStreams[0].raw.id)
+			return; // duplicate
+		this._addOutboundCandidate(stream);
+		if (this.outboundStreams.length === 1) {
+			this.dispatchEvent(new CustomEvent("stream:outbound"));
+			return;
+		}
+		this._scheduleOutboundPrune(true);
+	}
+
+	private pruneOutboundCandidates() {
+		try {
+			const candidates = this.outboundStreams;
+			if (!candidates.length) return;
+			const now = Date.now();
+			const healthy = candidates.filter(
+				(c: OutboundCandidate) => !c.aborted && c.bytesDelivered > 0,
 			);
-			try {
-				await stream.abort?.(
-					new AbortError("Superseded outbound stream" as any),
+			let chosen: OutboundCandidate | undefined;
+			if (healthy.length === 0) {
+				chosen = candidates.reduce(
+					(a: OutboundCandidate, b: OutboundCandidate) =>
+						b.created > a.created ? b : a,
 				);
-			} catch {}
-			return;
+			} else {
+				let bestScore = -Infinity;
+				for (const c of healthy) {
+					const age = now - c.created || 1;
+					const score = c.bytesDelivered / age;
+					if (
+						score > bestScore ||
+						(score === bestScore && chosen && c.created > chosen.created)
+					) {
+						bestScore = score;
+						chosen = c;
+					}
+				}
+			}
+			if (!chosen) return;
+			for (const c of candidates) {
+				if (c === chosen) continue; // never abort chosen
+				try {
+					c.raw.abort?.(new AbortError("Replaced outbound stream" as any));
+				} catch {
+					logger.error("Failed to abort outbound stream");
+				}
+				try {
+					c.pushable.return?.();
+				} catch {
+					logger.error("Failed to close outbound pushable");
+				}
+				try {
+					c.raw.close?.();
+				} catch {
+					logger.error("Failed to close outbound stream");
+				}
+			}
+			this.outboundStreams = [chosen];
+		} catch (e) {
+			logger.error(
+				"Error promoting outbound candidate: " + (e as any)?.message,
+			);
+		} finally {
+			this.dispatchEvent(new CustomEvent("stream:outbound"));
 		}
+	}
 
-		this.rawOutboundStream = stream;
-		this.outboundStream = pushableLanes({ lanes: 2 });
+	public forcePruneOutbound() {
+		if (this._outboundPruneTimer) {
+			clearTimeout(this._outboundPruneTimer);
+			this._outboundPruneTimer = undefined;
+		}
+		this.pruneOutboundCandidates();
+	}
 
-		this.outboundAbortController.signal.addEventListener("abort", () => {
-			this.rawOutboundStream?.close().catch((err) => {
-				this.rawOutboundStream?.abort(err);
-			});
-		});
+	/**
+	 * Internal helper to perform the actual outbound replacement & piping.
+	 */
+	// _replaceOutboundStream removed (legacy path)
 
-		pipe(
-			this.outboundStream,
-			(source) => lp.encode(source, { maxDataLength: MAX_DATA_LENGTH_OUT }),
-			this.rawOutboundStream,
-		).catch(logError);
+	// Debug/testing helper: list active outbound raw stream ids
+	public _debugActiveOutboundIds(): string[] {
+		if (this.outboundStreams.length) {
+			return this.outboundStreams.map((c) => c.raw.id);
+		}
+		return this.outboundStreams.map((c) => c.raw.id);
+	}
 
-		// Emit if the connection is new
-		this.dispatchEvent(new CustomEvent("stream:outbound"));
+	public _debugOutboundStats(): {
+		id: string;
+		bytes: number;
+		aborted: boolean;
+	}[] {
+		if (this.outboundStreams.length) {
+			return this.outboundStreams.map((c) => ({
+				id: c.raw.id,
+				bytes: c.bytesDelivered,
+				aborted: !!c.aborted,
+			}));
+		}
+		return this.outboundStreams.map((c) => ({
+			id: c.raw.id,
+			bytes: c.bytesDelivered,
+			aborted: !!c.aborted,
+		}));
 	}
 
 	/**
@@ -382,29 +677,49 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 		}
 
 		this.closed = true;
+		if (this._outboundPruneTimer) {
+			clearTimeout(this._outboundPruneTimer);
+			this._outboundPruneTimer = undefined;
+		}
 
 		// End the outbound stream
-		if (this.outboundStream != null) {
-			await this.outboundStream.return();
-			this.rawOutboundStream?.abort(new AbortError("Closed"));
+		if (this.outboundStreams.length) {
+			for (const c of this.outboundStreams) {
+				try {
+					await c.pushable.return?.();
+				} catch {}
+				try {
+					c.raw.abort?.(new AbortError("Closed"));
+				} catch {}
+			}
 			this.outboundAbortController.abort();
 		}
 
-		// End the inbound stream
-		if (this.inboundStream != null) {
-			this.inboundAbortController.abort();
-			await this.rawInboundStream?.close();
+		// End inbound streams
+		if (this.inboundStreams.length) {
+			for (const inbound of this.inboundStreams) {
+				try {
+					inbound.abortController.abort();
+				} catch {
+					logger.error("Failed to abort inbound stream");
+				}
+				try {
+					await inbound.raw.close?.();
+				} catch {
+					logger.error("Failed to close inbound stream");
+				}
+			}
 		}
 
 		this.usedBandWidthTracker.stop();
 
 		this.dispatchEvent(new CustomEvent("close"));
 
-		this.rawOutboundStream = undefined;
-		this.outboundStream = undefined;
+		this.outboundStreams = [];
 
 		this.rawInboundStream = undefined;
 		this.inboundStream = undefined;
+		this.inboundStreams = [];
 	}
 }
 
@@ -436,6 +751,7 @@ export type DirectStreamOptions = {
 	messageProcessingConcurrency?: number;
 	maxInboundStreams?: number;
 	maxOutboundStreams?: number;
+	inboundIdleTimeout?: number; // override PeerStreams.INBOUND_IDLE_MS
 	connectionManager?: ConnectionManagerArguments;
 	routeSeekInterval?: number;
 	seekTimeout?: number;
@@ -534,6 +850,7 @@ export abstract class DirectStream<
 			routeSeekInterval = ROUTE_UPDATE_DELAY_FACTOR,
 			seekTimeout = SEEK_DELIVERY_TIMEOUT,
 			routeMaxRetentionPeriod = ROUTE_MAX_RETANTION_PERIOD,
+			inboundIdleTimeout,
 		} = options || {};
 
 		const signKey = getKeypairFromPrivateKey(components.privateKey);
@@ -541,6 +858,10 @@ export abstract class DirectStream<
 		this.sign = signKey.sign.bind(signKey);
 		this.peerId = components.peerId;
 		this.publicKey = signKey.publicKey;
+		if (inboundIdleTimeout != null)
+			PeerStreams.INBOUND_IDLE_MS = inboundIdleTimeout;
+		if (maxInboundStreams != null)
+			PeerStreams.MAX_INBOUND_STREAMS = maxInboundStreams;
 		this.publicKeyHash = signKey.publicKey.hashcode();
 		this.multicodecs = multicodecs;
 		this.started = false;
@@ -795,8 +1116,8 @@ export abstract class DirectStream<
 		);
 
 		// handle inbound
-		const inboundStream = peer.attachInboundStream(stream);
-		this.processMessages(peer.publicKey, inboundStream, peer).catch(logError);
+		const inboundRecord = peer.attachInboundStream(stream);
+		this.processMessages(peer.publicKey, inboundRecord, peer).catch(logError);
 
 		// try to create outbound stream
 		await this.outboundInflightQueue.push({ peerId, connection });
@@ -1109,17 +1430,17 @@ export abstract class DirectStream<
 	 */
 	async processMessages(
 		peerId: PublicSignKey,
-		stream: AsyncIterable<Uint8ArrayList>,
+		record: InboundStreamRecord,
 		peerStreams: PeerStreams,
 	) {
 		try {
-			await pipe(stream, async (source) => {
-				for await (const data of source) {
-					this.processRpc(peerId, peerStreams, data).catch((e) => {
-						logError(e);
-					});
-				}
-			});
+			for await (const data of record.iterable) {
+				const now = Date.now();
+				record.lastActivity = now;
+				record.bytesReceived += data.length || data.byteLength || 0;
+
+				this.processRpc(peerId, peerStreams, data).catch((e) => logError(e));
+			}
 		} catch (err: any) {
 			if (err?.code === "ERR_STREAM_RESET") {
 				// only send stream reset messages to info
@@ -2241,9 +2562,8 @@ export abstract class DirectStream<
 
 	getQueuedBytes(): number {
 		let sum = 0;
-		for (const peer of this.peers) {
-			const out = peer[1].outboundStream;
-			sum += out ? out.readableLength : 0;
+		for (const [_k, ps] of this.peers) {
+			sum += measureOutboundQueuedBytes(ps as any); // cast to access hook
 		}
 		return sum;
 	}