@octanejs/app-core 0.0.56 → 0.0.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octanejs/app-core",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -79,10 +79,10 @@
     "esbuild": "^0.28.1"
   },
   "peerDependencies": {
-    "octane": "^0.5.0"
+    "octane": "^0.7.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",
-    "octane": "0.5.0"
+    "octane": "0.7.0"
   }
 }

package/src/server/node-http.js

@@ -212,7 +212,13 @@ export function nodeRequestToWebRequest(nodeRequest, nodeResponse) {
 
 /**
  * Pipe a Web Response to a Node.js ServerResponse. Streams chunk-by-chunk so a
- * streaming SSR body flushes as it renders (no buffering).
+ * streaming SSR body flushes as it renders (no buffering). A HEAD response ends
+ * with its headers and cancels the body.
+ *
+ * If the body fails, the returned promise rejects. Once headers were sent, the
+ * response has already been destroyed so the client observes an interrupted
+ * transfer; the caller must only report the error. Before that, the response's
+ * headers have been removed and the caller may send its own error response.
  *
  * @param {import('node:http').ServerResponse} nodeResponse
  * @param {Response} webResponse
@@ -237,6 +243,9 @@ async function sendWebResponseForRequest(nodeResponse, webResponse, nodeRequest)
 	if (nodeRequest && body && shouldGzip(nodeRequest, webResponse.status, headers, true)) {
 		headers.set('Content-Encoding', 'gzip');
 		headers.delete('Content-Length');
+		const etag = headers.get('ETag');
+		// A strong validator for the identity bytes cannot identify their gzip form.
+		if (etag !== null && !etag.startsWith('W/')) headers.delete('ETag');
 		// Sync-flush each input chunk so an SSR shell stays progressively
 		// observable instead of waiting for the final segment to close gzip.
 		const gzip = Duplex.toWeb(createGzip({ flush: zlibConstants.Z_SYNC_FLUSH }));
@@ -247,10 +256,24 @@ async function sendWebResponseForRequest(nodeResponse, webResponse, nodeRequest)
 
 	nodeResponse.statusCode = webResponse.status;
 	if (webResponse.statusText) nodeResponse.statusMessage = webResponse.statusText;
+	// `Headers` yields each Set-Cookie as its own entry, and `setHeader`
+	// replaces rather than appends, so cookies go over as one array: Node writes
+	// one header line per element. Commas cannot join them because `Expires`
+	// contains one.
 	headers.forEach((value, key) => {
-		nodeResponse.setHeader(key, value);
+		if (key !== 'set-cookie') nodeResponse.setHeader(key, value);
 	});
+	const cookies = headers.getSetCookie();
+	if (cookies.length) nodeResponse.setHeader('set-cookie', cookies);
 	if (body) {
+		// HEAD transfers metadata without content, and Node discards body writes.
+		// End now and release the producer instead of draining a body that may
+		// stay open indefinitely.
+		if (nodeResponse.req?.method === 'HEAD') {
+			if (!nodeResponse.destroyed) nodeResponse.end();
+			await body.cancel().catch(() => {});
+			return;
+		}
 		const reader = body.getReader();
 		let disconnected = nodeResponse.destroyed;
 		let disconnectReason = new Error('The client disconnected while streaming the response.');
@@ -280,7 +303,21 @@ async function sendWebResponseForRequest(nodeResponse, webResponse, nodeRequest)
 				if (!accepted && !disconnected) await waitForDrain(nodeResponse);
 			}
 		} catch (error) {
-			if (!disconnected) throw error;
+			if (!disconnected) {
+				if (nodeResponse.headersSent) {
+					// The status is committed, so an interrupted transfer is the only
+					// failure signal left; completing it would pass the partial body off
+					// as whole. Destroy without the error, which Node would otherwise
+					// report as a clientError: the caller reports it.
+					nodeResponse.destroy();
+				} else {
+					// Nothing is on the wire yet. Drop this representation's metadata so
+					// the caller's error response does not inherit its framing or encoding.
+					for (const name of headers.keys()) nodeResponse.removeHeader(name);
+				}
+				void cancelReader(error);
+				throw error;
+			}
 		} finally {
 			nodeResponse.off('close', onClose);
 			nodeResponse.off('error', onError);
@@ -490,10 +527,11 @@ export function createNodeServer(handler, options = {}) {
 			await sendWebResponseForRequest(res, response, req);
 		})().catch((error) => {
 			console.error('[octane] Request error:', error);
-			if (!res.headersSent) {
-				res.statusCode = 500;
-				res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-			}
+			// Once headers are sent the sender has aborted the transfer. Appending
+			// here would complete it with bytes the application never produced.
+			if (res.headersSent) return;
+			res.statusCode = 500;
+			res.setHeader('Content-Type', 'text/plain; charset=utf-8');
 			res.end('Internal Server Error');
 		});
 	});

package/src/server/server-entry.js

@@ -475,10 +475,10 @@ export async function nodeHandler(req, res) {
 		await sendWebResponse(res, response);
 	} catch (error) {
 		console.error('[octane] Request error:', error);
-		if (!res.headersSent) {
-			res.statusCode = 500;
-			res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-		}
+		// sendWebResponse already aborted a response whose headers were sent.
+		if (res.headersSent) return;
+		res.statusCode = 500;
+		res.setHeader('Content-Type', 'text/plain; charset=utf-8');
 		res.end('Internal Server Error');
 	}
 }

package/types/node.d.ts

@@ -13,7 +13,13 @@ export function nodeRequestToWebRequest(
 
 /**
  * Pipe a Web Response to a Node.js ServerResponse, streaming chunk-by-chunk
- * (a streaming SSR body flushes as it renders).
+ * (a streaming SSR body flushes as it renders). A HEAD response ends with its
+ * headers and cancels the body.
+ *
+ * Rejects when the body fails. If headers were already sent, the response has
+ * been destroyed so the client sees an interrupted transfer; only report the
+ * error. Otherwise the Web Response's headers were removed and the caller may
+ * send its own error response.
  */
 export function sendWebResponse(nodeResponse: ServerResponse, webResponse: Response): Promise<void>;