@oh-my-pi/pi-utils 15.12.3 → 15.12.4

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [15.12.4] - 2026-06-13
+
+### Fixed
+
+- Fixed abortable stream wrappers to cancel the source stream on abort, so timeout watchdogs release upstream HTTP bodies instead of only stopping the local reader.
+
 ## [15.12.0] - 2026-06-12
 
 ### Added

package/dist/types/abortable.d.ts

@@ -4,6 +4,11 @@ export declare class AbortError extends Error {
 /**
  * Creates an abortable stream from a given stream and signal.
  *
+ * Unlike `stream.pipeThrough(..., { signal })`, this explicitly cancels the
+ * source reader when the signal aborts. That propagates HTTP-client disconnects
+ * and stream watchdog timeouts all the way to the backend request instead of
+ * only stopping the local consumer.
+ *
  * @param stream - The stream to make abortable
  * @param signal - The signal to abort the stream
  * @returns The abortable stream

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-utils",
-	"version": "15.12.3",
+	"version": "15.12.4",
 	"description": "Shared utilities for pi packages",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -31,7 +31,7 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "15.12.3",
+		"@oh-my-pi/pi-natives": "15.12.4",
 		"beautiful-mermaid": "^1.1.3",
 		"handlebars": "^4.7.9",
 		"winston": "^3.19.0",

package/src/abortable.ts

@@ -10,16 +10,101 @@ export class AbortError extends Error {
 	}
 }
 
+type AbortableStreamReadResult<T> = { done: true; value?: T } | { done: false; value: T };
+
+interface AbortableStreamReader<T> {
+	read(): Promise<AbortableStreamReadResult<T>>;
+	cancel(reason?: unknown): Promise<void>;
+	releaseLock(): void;
+}
+
 /**
  * Creates an abortable stream from a given stream and signal.
  *
+ * Unlike `stream.pipeThrough(..., { signal })`, this explicitly cancels the
+ * source reader when the signal aborts. That propagates HTTP-client disconnects
+ * and stream watchdog timeouts all the way to the backend request instead of
+ * only stopping the local consumer.
+ *
  * @param stream - The stream to make abortable
  * @param signal - The signal to abort the stream
  * @returns The abortable stream
  */
 export function createAbortableStream<T>(stream: ReadableStream<T>, signal?: AbortSignal): ReadableStream<T> {
 	if (!signal) return stream;
-	return stream.pipeThrough(new TransformStream<T, T>(), { signal });
+	let reader: AbortableStreamReader<T> | undefined;
+	let closed = false;
+	let onAbort: (() => void) | undefined;
+
+	const cleanup = () => {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+		onAbort = undefined;
+		const currentReader = reader;
+		reader = undefined;
+		try {
+			currentReader?.releaseLock();
+		} catch {}
+	};
+
+	const cancelReader = (reason: unknown): Promise<void> => {
+		if (closed) return Promise.resolve();
+		closed = true;
+		const currentReader = reader;
+		reader = undefined;
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+		onAbort = undefined;
+		if (!currentReader) return Promise.resolve();
+		return currentReader
+			.cancel(reason)
+			.catch(() => {})
+			.finally(() => {
+				try {
+					currentReader.releaseLock();
+				} catch {}
+			});
+	};
+
+	return new ReadableStream<T>({
+		start(controller) {
+			reader = stream.getReader();
+			onAbort = () => {
+				void cancelReader(signal.reason);
+				try {
+					controller.error(new AbortError(signal));
+				} catch {}
+			};
+			if (signal.aborted) {
+				onAbort();
+				return;
+			}
+			signal.addEventListener("abort", onAbort, { once: true });
+			void (async () => {
+				try {
+					for (;;) {
+						const currentReader = reader;
+						if (!currentReader) return;
+						const { value, done } = await currentReader.read();
+						if (closed) return;
+						if (done) {
+							closed = true;
+							cleanup();
+							controller.close();
+							return;
+						}
+						controller.enqueue(value);
+					}
+				} catch (error) {
+					if (closed) return;
+					closed = true;
+					cleanup();
+					controller.error(signal.aborted ? new AbortError(signal) : error);
+				}
+			})();
+		},
+		cancel(reason) {
+			return cancelReader(reason);
+		},
+	});
 }
 
 /**