@donkeylabs/adapter-sveltekit 1.1.1 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/adapter-sveltekit",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "type": "module",
   "description": "SvelteKit adapter for @donkeylabs/server - seamless SSR/browser API integration",
   "main": "./src/index.ts",

package/src/generator/index.ts

@@ -197,16 +197,16 @@ function generateTypedSvelteKitClient(routes: RouteInfo[]): string {
         const inputType = `Routes.${pascalNs}.${pascalRoute}.Input`;
         const fullRouteName = commonPrefix ? `${commonPrefix}.${r.name}` : r.name;
         // Stream routes provide three methods:
-        // - fetch(input): POST request (programmatic)
+        // - fetch(input, options?): POST request (programmatic)
         // - url(input): GET URL for browser (video src, img src, download links)
-        // - get(input): GET fetch request
+        // - get(input, options?): GET fetch request
         return `    ${methodName}: {
       /** POST request with JSON body (programmatic) */
-      fetch: (input: ${inputType}): Promise<Response> => this.streamRequest("${fullRouteName}", input),
+      fetch: (input: ${inputType}, options?: RequestOptions): Promise<Response> => this.streamRequest("${fullRouteName}", input, options),
       /** GET URL for browser src attributes (video, img, download links) */
       url: (input: ${inputType}): string => this.streamUrl("${fullRouteName}", input),
       /** GET request with query params */
-      get: (input: ${inputType}): Promise<Response> => this.streamGet("${fullRouteName}", input),
+      get: (input: ${inputType}, options?: RequestOptions): Promise<Response> => this.streamGet("${fullRouteName}", input, options),
     }`;
       });
 

package/src/vite.ts

@@ -218,24 +218,43 @@ export function donkeylabsDev(options: DevPluginOptions = {}): Plugin {
                   res.setHeader(key, value);
                 }
 
-                // Handle body streaming
+                // Flush headers immediately for streaming responses
+                if (typeof res.flushHeaders === "function") {
+                  res.flushHeaders();
+                }
+
+                // Handle body streaming (non-blocking for continuous streams like MJPEG)
                 if (response.body) {
                   const reader = response.body.getReader();
+                  let closed = false;
+
+                  // Handle client disconnect
+                  req.on("close", () => {
+                    closed = true;
+                    reader.cancel().catch(() => {});
+                  });
+
+                  // Pump without awaiting - allows continuous streams
                   const pump = async () => {
                     try {
-                      while (true) {
+                      while (!closed) {
                         const { done, value } = await reader.read();
-                        if (done) {
-                          res.end();
+                        if (done || closed) {
+                          if (!closed) res.end();
                           break;
                         }
-                        res.write(value);
+                        // Write and check if client is still connected
+                        const canContinue = res.write(value);
+                        if (!canContinue && !closed) {
+                          // Backpressure - wait for drain
+                          await new Promise<void>(resolve => res.once("drain", resolve));
+                        }
                       }
                     } catch {
-                      res.end();
+                      if (!closed) res.end();
                     }
                   };
-                  await pump();
+                  pump(); // Don't await - let it run in background
                 } else {
                   res.end();
                 }