@jk2908/solas 0.13.0 → 0.13.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.13.2
+
+### Changed
+
+- The Node adapter's response-stream loop and close handlers use declarations and `while (true)` for readability. No behaviour change.
+
+## 0.13.1
+
+### Fixes
+
+- The Node adapter now aborts `request.signal` when the client disconnects, so streaming endpoints such as SSE can stop their producers.
+- The Node adapter flushes response headers before streaming the body, so a delayed first chunk no longer leaves the client waiting with no response.
+- The Node adapter cancels the response stream when the client disconnects, instead of continuing to write into a dead socket.
+
 ## 0.13.0
 
 ### Features

package/dist/adapters/node.js

@@ -1,4 +1,3 @@
-import { once } from 'node:events';
 import http from 'node:http';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -38,26 +37,59 @@ function nodeToWeb(req) {
  */
 async function webToNode(stream, res) {
     const reader = stream.getReader();
+    let closed = false;
+    // a client that goes away leaves nothing to write to; cancel the source so
+    // its producer stops instead of buffering into a dead socket
+    function onClose() {
+        closed = true;
+        void reader.cancel().catch(() => { });
+    }
+    res.once('close', onClose);
     try {
         while (true) {
+            if (closed)
+                break;
             const { done, value } = await reader.read();
             if (done)
                 break;
-            // `write` returns false when the socket buffer is full. That is not an
-            // error: wait for the `'drain'` event before writing more, otherwise a
-            // fast producer and a slow client would buffer the whole body in memory
-            if (!res.write(value))
-                await once(res, 'drain');
+            if (closed || res.destroyed || res.writableEnded)
+                break;
+            try {
+                // `write` returns false when the socket buffer is full. That is not an
+                // error: wait for the `'drain'` event before writing more, otherwise a
+                // fast producer and a slow client would buffer the whole body in memory
+                if (!res.write(value)) {
+                    await new Promise(resolve => {
+                        function settle() {
+                            res.off('drain', settle);
+                            res.off('close', settle);
+                            resolve();
+                        }
+                        res.on('drain', settle);
+                        res.on('close', settle);
+                    });
+                }
+            }
+            catch {
+                // the socket died between the checks above
+                break;
+            }
         }
     }
     finally {
-        reader.releaseLock();
+        res.off('close', onClose);
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // a pending read can outlive a cancel by a tick
+        }
     }
 }
 /**
  * Convert a Node request into a fetch `Request`, streaming the body when present.
  */
-function toRequest(req) {
+function toRequest(req, signal) {
     const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
     const headers = new Headers();
     for (const [key, value] of Object.entries(req.headers)) {
@@ -77,6 +109,7 @@ function toRequest(req) {
         headers,
         body: hasBody ? nodeToWeb(req) : undefined,
         duplex: 'half',
+        signal,
     };
     return new Request(url, init);
 }
@@ -99,8 +132,12 @@ async function sendResponse(res, response) {
         res.end();
         return;
     }
+    // send headers now so a delayed first chunk (SSE, slow streams) does not
+    // leave the client waiting with no response
+    res.flushHeaders();
     await webToNode(response.body, res);
-    res.end();
+    if (!res.destroyed)
+        res.end();
 }
 /**
  * Start a production HTTP server for a Node (or Bun) deployment.
@@ -121,16 +158,31 @@ async function adapter(options = {}) {
     const host = options.host ?? '0.0.0.0';
     const handler = await loadHandler(entry);
     const server = http.createServer(async (req, res) => {
+        const abort = new AbortController();
+        // `close` before the response has finished means the client went away;
+        // surface that through `req.signal` so long-lived work can stop
+        function onClose() {
+            if (!res.writableEnded)
+                abort.abort(new Error('client disconnected'));
+        }
+        res.once('close', onClose);
         try {
-            const response = await handler.fetch(toRequest(req));
+            const response = await handler.fetch(toRequest(req, abort.signal));
             await sendResponse(res, response);
         }
         catch (err) {
             console.error('[solas] request failed', err);
+            if (res.headersSent) {
+                res.destroy();
+                return;
+            }
             res.statusCode = 500;
             res.setHeader('content-type', 'text/plain; charset=utf-8');
             res.end('Internal Server Error');
         }
+        finally {
+            res.off('close', onClose);
+        }
     });
     await new Promise(resolve => server.listen(port, host, resolve));
     options.onListen?.({ port, host });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.13.0",
+	"version": "0.13.2",
 	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",