@pasko70/pibo 3.5.0 → 3.5.1

package/dist/web/http.js

@@ -78,74 +78,136 @@ export async function nodeRequestToWebRequest(request, baseURL, signal) {
     });
 }
 export async function sendWebResponse(response, webResponse, options = {}) {
+    assertResponseCanStart(response);
     const headers = responseHeaders(webResponse);
     const compressEncoding = preferredResponseEncoding(response.req?.headers["accept-encoding"], webResponse);
-    if (compressEncoding && webResponse.body) {
-        const body = await readResponseBody(webResponse);
-        if (body.length >= MIN_COMPRESS_RESPONSE_BYTES && body.length <= MAX_SYNC_GZIP_RESPONSE_BYTES) {
-            const compressionStartedAt = performance.now();
-            const compressed = gzipSync(body, { level: 1 });
-            appendServerTimingHeader(headers, `response_compress;dur=${(performance.now() - compressionStartedAt).toFixed(1)}`);
-            headers["content-encoding"] = compressEncoding;
-            headers["content-length"] = String(compressed.length);
-            headers.vary = appendVary(headers.vary, "accept-encoding");
+    let reader = webResponse.body?.getReader();
+    let wroteHeaders = false;
+    let clientClosed = false;
+    const cancelReader = () => {
+        if (reader)
+            void reader.cancel().catch(() => undefined);
+    };
+    const close = () => {
+        clientClosed = true;
+        cancelReader();
+    };
+    const abort = () => {
+        cancelReader();
+        try {
+            if (!response.destroyed && !response.writableEnded)
+                response.end();
+        }
+        catch {
+            tryDestroyResponse(response);
+        }
+        try {
+            response.socket?.end();
+        }
+        catch {
+            tryDestroyResponse(response);
+        }
+    };
+    if (reader) {
+        response.once("close", close);
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+    }
+    try {
+        if (compressEncoding && reader) {
+            const body = await readResponseBody(reader);
+            if (clientClosed || options.signal?.aborted || response.destroyed || response.writableEnded || response.writableFinished)
+                return;
+            assertResponseCanStart(response);
+            if (body.length >= MIN_COMPRESS_RESPONSE_BYTES && body.length <= MAX_SYNC_GZIP_RESPONSE_BYTES) {
+                const compressionStartedAt = performance.now();
+                const compressed = gzipSync(body, { level: 1 });
+                appendServerTimingHeader(headers, `response_compress;dur=${(performance.now() - compressionStartedAt).toFixed(1)}`);
+                headers["content-encoding"] = compressEncoding;
+                headers["content-length"] = String(compressed.length);
+                headers.vary = appendVary(headers.vary, "accept-encoding");
+                response.writeHead(webResponse.status, headers);
+                wroteHeaders = true;
+                response.end(compressed);
+                return;
+            }
+            if (body.length > MAX_SYNC_GZIP_RESPONSE_BYTES) {
+                headers["x-pibo-compression-skipped"] = "sync-gzip-size-limit";
+            }
             response.writeHead(webResponse.status, headers);
-            response.end(compressed);
+            wroteHeaders = true;
+            response.end(body);
             return;
         }
-        if (body.length > MAX_SYNC_GZIP_RESPONSE_BYTES) {
-            headers["x-pibo-compression-skipped"] = "sync-gzip-size-limit";
-        }
         response.writeHead(webResponse.status, headers);
-        response.end(body);
-        return;
-    }
-    response.writeHead(webResponse.status, headers);
-    if (!webResponse.body) {
-        response.end();
-        return;
-    }
-    const reader = webResponse.body.getReader();
-    const cancel = () => {
-        void reader.cancel().catch(() => undefined);
-    };
-    const abort = () => {
-        const socket = response.socket;
-        void reader.cancel().catch(() => undefined);
-        if (!response.writableEnded)
+        wroteHeaders = true;
+        if (!reader) {
             response.end();
-        socket?.end();
-    };
-    response.once("close", cancel);
-    options.signal?.addEventListener("abort", abort, { once: true });
-    if (options.signal?.aborted)
-        abort();
-    try {
+            return;
+        }
         while (true) {
             const { done, value } = await reader.read();
             if (done)
                 break;
             const bytes = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
             for (let offset = 0; offset < bytes.length; offset += 64 * 1024) {
-                if (response.destroyed || response.writableEnded)
+                if (response.destroyed || response.writableEnded || response.writableFinished) {
+                    cancelReader();
                     return;
+                }
                 if (!response.write(bytes.subarray(offset, offset + 64 * 1024))) {
                     const drained = await waitForResponseDrain(response, (webResponse.headers.get("content-type") ?? "").startsWith("text/event-stream") ? 5000 : undefined, options.signal);
                     if (!drained) {
-                        void reader.cancel().catch(() => undefined);
-                        if (!response.destroyed)
-                            response.destroy();
+                        cancelReader();
+                        tryDestroyResponse(response);
                         return;
                     }
                 }
             }
         }
-        if (!response.writableEnded)
+        if (!response.destroyed && !response.writableEnded && !response.writableFinished)
             response.end();
     }
+    catch (error) {
+        cancelReader();
+        if (clientClosed || response.destroyed || response.writableEnded || response.writableFinished)
+            return;
+        if (wroteHeaders || response.headersSent)
+            tryDestroyResponse(response, error);
+        throw error;
+    }
     finally {
-        response.off("close", cancel);
+        response.off("close", close);
         options.signal?.removeEventListener("abort", abort);
+        if (reader) {
+            try {
+                reader.releaseLock();
+            }
+            catch {
+                // Cancellation/read settlement owns the lock until the pending read resolves.
+            }
+        }
+    }
+}
+function assertResponseCanStart(response) {
+    if (response.destroyed)
+        throw new Error("HTTP response is destroyed");
+    if (response.writableEnded)
+        throw new Error("HTTP response has ended");
+    if (response.writableFinished)
+        throw new Error("HTTP response has finished");
+    if (response.headersSent)
+        throw new Error("HTTP response headers were already sent");
+}
+function tryDestroyResponse(response, error) {
+    if (response.destroyed)
+        return;
+    try {
+        response.destroy(error instanceof Error ? error : undefined);
+    }
+    catch {
+        // The request boundary is best-effort once the response implementation itself fails.
     }
 }
 function appendServerTimingHeader(headers, value) {
@@ -198,9 +260,8 @@ function responseCanBeCompressed(webResponse) {
     const contentType = webResponse.headers.get("content-type") ?? "";
     return /^application\/json\b/.test(contentType);
 }
-async function readResponseBody(webResponse) {
+async function readResponseBody(reader) {
     const chunks = [];
-    const reader = webResponse.body.getReader();
     while (true) {
         const { done, value } = await reader.read();
         if (done)

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.5.0",
+  "version": "3.5.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "3.5.0",
+      "version": "3.5.1",
       "workspaces": [
         "packages/workflows"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.5.0",
+  "version": "3.5.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",