@jk2908/solas 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.14.0
+
+### Breaking
+
+- Runtime helpers moved out of `@jk2908/solas/adapters/*`: `serve` is now a named export from `@jk2908/solas/runtime/node`, and `createWorker`/`createCloudflareAssets` are now `@jk2908/solas/runtime/cloudflare`. The old `@jk2908/solas/adapters/node` and `@jk2908/solas/adapters/cloudflare/runtime` entries are removed. `@jk2908/solas/adapters/*` now contains build adapters only.
+
+## 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/README.md

@@ -659,18 +659,18 @@ Because workers have no filesystem, the Worker reads its own output through the
 `cloudflare()` forwards its `cloudflare` option to `@cloudflare/vite-plugin`. To build a Worker manually, `createWorker` composes the entry behaviour, and `createCloudflareAssets` builds the store directly:
 
 ```ts
-import { createCloudflareAssets } from '@jk2908/solas/adapters/cloudflare/runtime'
+import { createCloudflareAssets } from '@jk2908/solas/runtime/cloudflare'
 
 const assets = createCloudflareAssets(env)
 ```
 
 ## Node
 
-`vite dev` and `vite preview` already run the built handler in Node (via `@vitejs/plugin-rsc`'s default server handler), so nothing extra is needed locally. For a production Node server, use `@jk2908/solas/adapters/node`:
+`vite dev` and `vite preview` already run the built handler in Node (via `@vitejs/plugin-rsc`'s default server handler), so nothing extra is needed locally. For a production Node server, use `@jk2908/solas/runtime/node`:
 
 ```ts
 // server.ts
-import serve from '@jk2908/solas/adapters/node'
+import { serve } from '@jk2908/solas/runtime/node'
 
 await serve()
 ```
@@ -686,6 +686,8 @@ await serve()
 
 `serve()` loads the built RSC entry (`dist/rsc/index.js` by default) and forwards requests to its fetch handler, which already serves prerendered routes, client assets, and RSC/SSR responses. Options: `port` (defaults to `PORT` or `3000`), `host`, `outDir`, and `entry`. Run from the project root so the handler can resolve `dist`.
 
+`serve` is a runtime helper, not a build adapter: it starts an HTTP server and returns it, so it belongs in `server.ts`. Do not pass it to `solas({ adapter })`; that option expects an `Adapter` with `name` and `plugins`, such as `cloudflare()` or the static adapter.
+
 Bun and Deno do not need the helper. Their native servers pass the handler a `Request` directly and expect a `Response`, so the Node-specific HTTP-to-Fetch bridging (streams, `duplex`, backpressure) is not needed:
 
 ```ts
@@ -702,7 +704,7 @@ import handler from './dist/rsc/index.js'
 Deno.serve(request => handler.fetch(request))
 ```
 
-The handler reads `dist` through `node:fs`, which Bun and Deno (2.x, via Node compat) provide. Run from the project root. Bun can also run `@jk2908/solas/adapters/node` as-is, since it implements `node:http`.
+The handler reads `dist` through `node:fs`, which Bun and Deno (2.x, via Node compat) provide. Run from the project root. Bun can also run `@jk2908/solas/runtime/node` as-is, since it implements `node:http`.
 
 ## Static
 
@@ -731,7 +733,7 @@ Server actions and runtime endpoints also need a server, so the build warns when
 
 ## Runtime
 
-At request time Solas reads its output through an `Assets` interface (`exists`/`readText`/`readBuffer`/`mimeType`) injected into `createHandler`, defaulting to the Node standard library (which Bun runs natively). References are logical (`{ namespace, path }`), where the namespaces are `client` (Vite client output), `static` (full prerenders), and `artifact` (runtime manifest and ppr files). Platforms without a filesystem provide their own store; `@jk2908/solas/adapters/cloudflare/runtime` builds one around the `ASSETS` binding via `createWorker`. Build-time reads and writes use `node:fs` directly and are not abstracted.
+At request time Solas reads its output through an `Assets` interface (`exists`/`readText`/`readBuffer`/`mimeType`) injected into `createHandler`, defaulting to the Node standard library (which Bun runs natively). References are logical (`{ namespace, path }`), where the namespaces are `client` (Vite client output), `static` (full prerenders), and `artifact` (runtime manifest and ppr files). Platforms without a filesystem provide their own store; `@jk2908/solas/runtime/cloudflare` builds one around the `ASSETS` binding via `createWorker`. Build-time reads and writes use `node:fs` directly and are not abstracted.
 
 ## Scripts
 

package/dist/adapters/cloudflare/vite.js

@@ -4,7 +4,7 @@ import { cloudflare as cloudflareVitePlugin } from '@cloudflare/vite-plugin';
 import * as Config from '../../config.js';
 import { writeCloudflareEntry } from '../../internal/codegen/environments.js';
 import { setPrerenderImport, setRscEntry } from '../../internal/postbuild.js';
-import { NAMESPACE_PREFIX } from './assets.js';
+import { NAMESPACE_PREFIX } from '../../runtime/cloudflare/assets.js';
 import { withBindingsShim } from './bindings.js';
 const VIRTUAL_ENTRY = 'virtual:solas-cloudflare-entry';
 /**

package/dist/internal/codegen/environments.js

@@ -31,7 +31,7 @@ export function writeCloudflareEntry() {
     return source `
 		${AUTOGEN_MSG}
 
-		import { createWorker } from '${Config.PKG_NAME}/adapters/cloudflare/runtime'
+		import { createWorker } from '${Config.PKG_NAME}/runtime/cloudflare'
 
 		import { manifest } from './manifest.js'
 		import { importMap } from './maps.js'

package/dist/{adapters → runtime}/node.d.ts

@@ -38,7 +38,7 @@ export type Server = http.Server & AsyncDisposable;
  * Deno and Bun do not need this helper: use `Deno.serve(handler.fetch)` or
  * `Bun.serve({ fetch: handler.fetch })` directly.
  */
-declare function adapter(options?: ServeOptions): Promise<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> & {
+declare function serve(options?: ServeOptions): Promise<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> & {
     [Symbol.asyncDispose](): Promise<void>;
 }>;
-export { adapter as default };
+export { serve };

package/dist/{adapters → runtime}/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.
@@ -114,23 +151,38 @@ async function sendResponse(res, response) {
  * Deno and Bun do not need this helper: use `Deno.serve(handler.fetch)` or
  * `Bun.serve({ fetch: handler.fetch })` directly.
  */
-async function adapter(options = {}) {
+async function serve(options = {}) {
     const outDir = options.outDir ?? 'dist';
     const entry = path.resolve(options.entry ?? path.join(outDir, 'rsc', 'index.js'));
     const port = options.port ?? (Number(process.env.PORT) || 3000);
     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 });
@@ -142,4 +194,4 @@ async function adapter(options = {}) {
         },
     });
 }
-export { adapter as default };
+export { serve };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.13.0",
+	"version": "0.14.0",
 	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",
@@ -73,17 +73,17 @@
 			"types": "./dist/adapters/cloudflare/index.d.ts",
 			"import": "./dist/adapters/cloudflare/index.js"
 		},
-		"./adapters/cloudflare/runtime": {
-			"types": "./dist/adapters/cloudflare/runtime.d.ts",
-			"import": "./dist/adapters/cloudflare/runtime.js"
-		},
-		"./adapters/node": {
-			"types": "./dist/adapters/node.d.ts",
-			"import": "./dist/adapters/node.js"
-		},
 		"./adapters/static": {
 			"types": "./dist/adapters/static.d.ts",
 			"import": "./dist/adapters/static.js"
+		},
+		"./runtime/cloudflare": {
+			"types": "./dist/runtime/cloudflare/index.d.ts",
+			"import": "./dist/runtime/cloudflare/index.js"
+		},
+		"./runtime/node": {
+			"types": "./dist/runtime/node.d.ts",
+			"import": "./dist/runtime/node.js"
 		}
 	},
 	"scripts": {