akanjs 2.2.12 → 2.2.13-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.2.12",
+  "version": "2.2.13-rc.0",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/akanApp.ts

@@ -84,6 +84,8 @@ export class AkanApp {
   #logWriter: RotatingLogWriter | null = null;
   #removeLogSink: (() => void) | null = null;
   readonly #childOutputBuffers = new Map<string, string>();
+  readonly #childStderrBlockBuffers = new Map<string, string[]>();
+  readonly #childStderrBlockTimers = new Map<string, ReturnType<typeof setTimeout>>();
   static readonly #ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
   #gatewayMetrics: AkanMetricsReport = {};
   #proxyHopCount = 0;
@@ -1004,6 +1006,7 @@ export class AkanApp {
       if (remaining) this.#writeChildOutput(idx, role, type, bufferKey, remaining);
     } finally {
       this.#flushChildOutput(idx, role, type, bufferKey);
+      if (type === "stderr") this.#flushChildStderrBlock(idx, role, AkanApp.#childStderrBlockKey(idx, role));
     }
   }
 
@@ -1028,11 +1031,63 @@ export class AkanApp {
   }
 
   #writeChildOutputLine(idx: number, role: AkanChildRole, type: "stdout" | "stderr", line: string) {
+    if (type === "stderr" && this.#bufferChildStderrLine(idx, role, line)) return;
+    this.#writeChildOutputLineRaw(idx, role, type, line);
+  }
+
+  #writeChildOutputLineRaw(idx: number, role: AkanChildRole, type: "stdout" | "stderr", line: string) {
     const prefixedLine = `[child:${idx} ${role}] [${type}] ${line}`;
     process[type].write(prefixedLine);
     this.#logWriter?.write(`${idx}-${role}`, AkanApp.#stripAnsi(prefixedLine));
   }
 
+  #bufferChildStderrLine(idx: number, role: AkanChildRole, line: string): boolean {
+    const key = AkanApp.#childStderrBlockKey(idx, role);
+    const block = this.#childStderrBlockBuffers.get(key) ?? [];
+    block.push(line);
+    this.#childStderrBlockBuffers.set(key, block);
+
+    const existingTimer = this.#childStderrBlockTimers.get(key);
+    if (existingTimer) clearTimeout(existingTimer);
+
+    if (line.trim() === "" || block.length >= 64) {
+      this.#flushChildStderrBlock(idx, role, key);
+      return true;
+    }
+
+    this.#childStderrBlockTimers.set(
+      key,
+      setTimeout(() => this.#flushChildStderrBlock(idx, role, key), 50),
+    );
+    return true;
+  }
+
+  #flushChildStderrBlock(idx: number, role: AkanChildRole, key: string) {
+    const timer = this.#childStderrBlockTimers.get(key);
+    if (timer) clearTimeout(timer);
+    this.#childStderrBlockTimers.delete(key);
+
+    const block = this.#childStderrBlockBuffers.get(key);
+    if (!block?.length) return;
+    this.#childStderrBlockBuffers.delete(key);
+
+    const text = block.join("");
+    if (AkanApp.#isBenignRsdwConnectionClosedBlock(text)) return;
+    for (const blockLine of block) this.#writeChildOutputLineRaw(idx, role, "stderr", blockLine);
+  }
+
+  static #childStderrBlockKey(idx: number, role: AkanChildRole): string {
+    return `${idx}:${role}:stderr`;
+  }
+
+  static #isBenignRsdwConnectionClosedBlock(text: string): boolean {
+    return (
+      text.includes('reportGlobalError(weakResponse, Error("Connection closed."))') &&
+      text.includes("error: Connection closed.") &&
+      text.includes("react-server-dom-webpack")
+    );
+  }
+
   static #stripAnsi(msg: string) {
     return msg.replace(AkanApp.#ansiPattern, "");
   }

package/server/rscWorker.tsx

@@ -13,6 +13,7 @@ import type { ClientManifest } from "./artifact";
 import { ProcessMetricsCollector } from "./processMetricsCollector";
 import { RouteElementComposer } from "./routeElementComposer";
 import { type PagesContext, RouteTreeBuilder } from "./routeTreeBuilder";
+import { replayCachedRscResult } from "./rscWorkerReplay";
 import { createSystemPageDocument, getSystemPageHomeHref } from "./systemPages";
 
 interface InitMsg {
@@ -32,6 +33,10 @@ interface RenderMsg {
   headers?: Record<string, string>;
   clientManifest?: ClientManifest;
 }
+interface CancelMsg {
+  type: "cancel";
+  requestId: string;
+}
 interface ReloadMsg {
   type: "reload";
   clientManifest: ClientManifest;
@@ -44,11 +49,19 @@ interface UpdateCssAssetsMsg {
   type: "updateCssAssets";
   cssAssets: Record<string, { cssUrl: string; cssRelPath: string }>;
 }
-type InMsg = InitMsg | RenderMsg | ReloadMsg | UpdateCssAssetsMsg;
+type InMsg = InitMsg | RenderMsg | CancelMsg | ReloadMsg | UpdateCssAssetsMsg;
 type RenderControl =
   | { type: "redirect"; location: string; method: "replace" | "push"; status: RedirectStatus }
   | { type: "not-found" }
   | { type: "error"; error: unknown };
+interface FlightRenderResult {
+  chunks: Uint8Array[];
+  bytes: number;
+  chunksCount: number;
+  control: RenderControl | null;
+  lateControlSent: boolean;
+  cancelled: boolean;
+}
 
 interface RscRendererStats {
   renderCount: number;
@@ -128,6 +141,8 @@ class RscRenderer {
   };
   readonly #routeStats = new Map<string, RouteRenderStats>();
   readonly #resultCache = new Map<string, CachedRscResult>();
+  readonly #activeRenderReaders = new Map<string, ReadableStreamDefaultReader<Uint8Array>>();
+  readonly #cancelledRenderRequests = new Set<string>();
   #resultCacheHits = 0;
   #resultCacheMisses = 0;
   #resultCacheBypass = 0;
@@ -158,6 +173,10 @@ class RscRenderer {
         this.#logger.verbose(`received render requestId=${msg.requestId} url=${msg.url} method=${msg.method ?? "GET"}`);
         void this.#handleRender(msg);
         return;
+      case "cancel":
+        this.#logger.verbose(`received cancel requestId=${msg.requestId}`);
+        this.#handleCancel(msg.requestId);
+        return;
       case "reload":
         this.#logger.verbose(`received reload buildId=${msg.buildId}`);
         void this.#handleReload(msg);
@@ -169,6 +188,14 @@ class RscRenderer {
     }
   }
 
+  #handleCancel(requestId: string): void {
+    this.#cancelledRenderRequests.add(requestId);
+    const reader = this.#activeRenderReaders.get(requestId);
+    if (!reader) return;
+    void reader.cancel().catch(() => {
+    });
+  }
+
   async #handleInit(msg: InitMsg): Promise<void> {
     const startedAt = Date.now();
     try {
@@ -300,27 +327,42 @@ class RscRenderer {
           this.#stats.totalFlightBytes += cached.bytes;
           this.#stats.totalFlightChunks += cached.chunksCount;
           this.#recordRouteStats(routeId, cached.bytes, this.#stats.lastRenderDurationMs);
-          this.#send({ type: "meta", requestId, theme: cached.theme });
-          for (const chunk of cached.chunks) this.#send({ type: "chunk", requestId, data: chunk });
-          this.#send({ type: "end", requestId });
+          await replayCachedRscResult({
+            requestId,
+            chunks: cached.chunks,
+            theme: cached.theme,
+            send: (message) => this.#send(message),
+            isCancelled: () => this.#cancelledRenderRequests.has(requestId),
+          });
           return;
         }
         const theme = cookies().get("theme")?.value;
-        const element = match ? await this.#renderMatched(urlObj, match, theme) : await this.#renderNotFound(urlObj);
+        const searchParams = RouteTreeBuilder.parseSearchParams(urlObj.search);
+        let element: ReactNode;
+        if (match) element = await this.#renderMatched(urlObj, match, theme, searchParams);
+        else element = await this.#renderNotFound(urlObj);
         this.#logger.verbose(`render[${requestId}] starting Flight stream`);
-        const result = await this.#renderFlightElement(element, msg.clientManifest ?? this.#clientManifest);
+        const result = await this.#renderFlightElement(element, msg.clientManifest ?? this.#clientManifest, {
+          requestId,
+          collectChunks: cacheKey !== null,
+          status: match ? undefined : 404,
+        });
+        if (result.cancelled) return;
         const control = result.control;
         if (control) {
           this.#stats.lastRenderKind = control.type;
+          if (result.lateControlSent) {
+            this.#logger.verbose(`render[${requestId}] late ${control.type} delivered after stream start`);
+            return;
+          }
           if (!match && control.type === "error") {
             const systemResult = await this.#renderFlightElement(
               this.#renderSystemNotFound(urlObj),
               msg.clientManifest ?? this.#clientManifest,
+              { requestId, status: 404 },
             );
+            if (systemResult.cancelled) return;
             if (!systemResult.control) {
-              this.#send({ type: "meta", requestId, theme: getRequestTheme(), status: 404 });
-              for (const chunk of systemResult.chunks) this.#send({ type: "chunk", requestId, data: chunk });
-              this.#send({ type: "end", requestId });
               return;
             }
           }
@@ -332,7 +374,7 @@ class RscRenderer {
               kind: control.type,
               route: match.pathRoute,
               params: match.params,
-              searchParams: RouteTreeBuilder.parseSearchParams(urlObj.search),
+              searchParams,
               pathname: urlObj.pathname,
               url: urlObj,
               error: control.type === "error" ? control.error : undefined,
@@ -345,9 +387,9 @@ class RscRenderer {
           return;
         }
         this.#stats.lastFlightBytes = result.bytes;
-        this.#stats.lastFlightChunks = result.chunks.length;
+        this.#stats.lastFlightChunks = result.chunksCount;
         this.#stats.totalFlightBytes += result.bytes;
-        this.#stats.totalFlightChunks += result.chunks.length;
+        this.#stats.totalFlightChunks += result.chunksCount;
         this.#stats.lastRenderDurationMs = Date.now() - startedAt;
         const afterLoadedKeys = RouteTreeBuilder.getCacheStats().loadedModuleKeys;
         this.#stats.lastRenderLoadedModules = afterLoadedKeys.filter((key) => !beforeLoadedKeys.includes(key));
@@ -358,17 +400,12 @@ class RscRenderer {
           this.#setCachedResult(cacheKey, {
             chunks: result.chunks,
             bytes: result.bytes,
-            chunksCount: result.chunks.length,
+            chunksCount: result.chunksCount,
             theme: responseTheme,
           });
-        this.#send({ type: "meta", requestId, theme: responseTheme, status: match ? undefined : 404 });
-        for (const chunk of result.chunks) {
-          this.#send({ type: "chunk", requestId, data: chunk });
-        }
         this.#logger.verbose(
-          `render[${requestId}] done chunks=${result.chunks.length} bytes=${result.bytes} in ${Date.now() - startedAt}ms`,
+          `render[${requestId}] done chunks=${result.chunksCount} bytes=${result.bytes} in ${Date.now() - startedAt}ms`,
         );
-        this.#send({ type: "end", requestId });
       });
     } catch (error) {
       if (isAkanRedirectError(error)) {
@@ -435,6 +472,8 @@ class RscRenderer {
         message: error instanceof Error ? error.message : String(error),
       });
     } finally {
+      this.#activeRenderReaders.delete(requestId);
+      this.#cancelledRenderRequests.delete(requestId);
       this.#stats.inFlightRenderCount = Math.max(0, this.#stats.inFlightRenderCount - 1);
     }
   }
@@ -484,7 +523,12 @@ class RscRenderer {
   async #renderFlightElement(
     element: ReactNode,
     clientManifest: ClientManifest,
-  ): Promise<{ chunks: Uint8Array[]; bytes: number; control: RenderControl | null }> {
+    options: {
+      requestId?: string;
+      collectChunks?: boolean;
+      status?: number;
+    } = {},
+  ): Promise<FlightRenderResult> {
     const controlRef: { current: RenderControl | null } = { current: null };
     const stream = await renderToReadableStream(element, clientManifest, {
       onError: (error) => {
@@ -506,20 +550,77 @@ class RscRenderer {
       },
     });
     const reader = stream.getReader();
+    if (options.requestId) this.#activeRenderReaders.set(options.requestId, reader);
     let bytes = 0;
+    let chunksCount = 0;
+    let sentMeta = false;
+    let sentChunk = false;
+    let lateControlSent = false;
     const chunks: Uint8Array[] = [];
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      if (controlRef.current) {
-        await reader.cancel();
-        break;
+    const sendMeta = () => {
+      if (!options.requestId || sentMeta) return;
+      sentMeta = true;
+      this.#send({ type: "meta", requestId: options.requestId, theme: getRequestTheme(), status: options.status });
+    };
+    const sendLateRedirect = () => {
+      if (!options.requestId || lateControlSent || controlRef.current?.type !== "redirect") return;
+
+      lateControlSent = true;
+      this.#send({
+        type: "late-redirect",
+        requestId: options.requestId,
+        location: controlRef.current.location,
+        method: controlRef.current.method,
+        status: controlRef.current.status,
+      });
+    };
+    try {
+      while (true) {
+        if (options.requestId && this.#cancelledRenderRequests.has(options.requestId)) {
+          await reader.cancel();
+          return { chunks, bytes, chunksCount, control: null, lateControlSent, cancelled: true };
+        }
+        const { value, done } = await reader.read();
+        if (controlRef.current && !sentChunk) {
+          await reader.cancel();
+          return { chunks, bytes, chunksCount, control: controlRef.current, lateControlSent, cancelled: false };
+        }
+        if (controlRef.current && sentChunk) sendLateRedirect();
+        if (done) break;
+        const chunk = value instanceof Uint8Array ? value : new Uint8Array(value as ArrayBufferLike);
+        bytes += chunk.byteLength;
+        chunksCount += 1;
+        if (options.collectChunks) chunks.push(chunk);
+        if (options.requestId) {
+          sendMeta();
+          this.#send({ type: "chunk", requestId: options.requestId, data: chunk });
+          sentChunk = true;
+        }
+      }
+    } catch (error) {
+      if (options.requestId && this.#cancelledRenderRequests.has(options.requestId)) {
+        return { chunks, bytes, chunksCount, control: null, lateControlSent, cancelled: true };
       }
-      const chunk = value instanceof Uint8Array ? value : new Uint8Array(value as ArrayBufferLike);
-      bytes += chunk.byteLength;
-      chunks.push(chunk);
+      throw error;
+    } finally {
+      if (options.requestId) this.#activeRenderReaders.delete(options.requestId);
+      reader.releaseLock();
+    }
+    if (controlRef.current && sentChunk) sendLateRedirect();
+    if (controlRef.current && !sentChunk)
+      return { chunks, bytes, chunksCount, control: controlRef.current, lateControlSent, cancelled: false };
+    if (options.requestId) {
+      sendMeta();
+      this.#send({ type: "end", requestId: options.requestId });
     }
-    return { chunks, bytes, control: controlRef.current };
+    return {
+      chunks,
+      bytes,
+      chunksCount,
+      control: lateControlSent ? controlRef.current : null,
+      lateControlSent,
+      cancelled: false,
+    };
   }
 
   async #trySendFallbackRender({
@@ -555,15 +656,16 @@ class RscRenderer {
         digest: kind === "error" ? "AKAN_RENDER_ERROR" : undefined,
       });
       if (!element) return false;
-      const result = await this.#renderFlightElement(element, clientManifest);
+      const result = await this.#renderFlightElement(element, clientManifest, {
+        requestId,
+        status: kind === "not-found" ? 404 : 500,
+      });
+      if (result.cancelled) return true;
       if (result.control) return false;
-      this.#send({ type: "meta", requestId, theme: getRequestTheme(), status: kind === "not-found" ? 404 : 500 });
-      for (const chunk of result.chunks) this.#send({ type: "chunk", requestId, data: chunk });
-      this.#send({ type: "end", requestId });
       this.#stats.lastFlightBytes = result.bytes;
-      this.#stats.lastFlightChunks = result.chunks.length;
+      this.#stats.lastFlightChunks = result.chunksCount;
       this.#stats.totalFlightBytes += result.bytes;
-      this.#stats.totalFlightChunks += result.chunks.length;
+      this.#stats.totalFlightChunks += result.chunksCount;
       return true;
     } catch (fallbackError) {
       this.#logger.error(
@@ -735,8 +837,8 @@ class RscRenderer {
     url: URL,
     match: { pathRoute: PathRoute; params: Record<string, string> },
     theme?: string,
+    searchParams = RouteTreeBuilder.parseSearchParams(url.search),
   ): Promise<ReactNode> {
-    const searchParams = RouteTreeBuilder.parseSearchParams(url.search);
     this.#logger.verbose(
       `composing route element pathname=${url.pathname} search=${url.search || "(none)"} params=${JSON.stringify(match.params)}`,
     );
@@ -745,7 +847,11 @@ class RscRenderer {
       params: match.params,
       searchParams,
     });
-    const body = RouteElementComposer.compose({ pathRoute: match.pathRoute, params: match.params, searchParams });
+    const body = RouteElementComposer.compose({
+      pathRoute: match.pathRoute,
+      params: match.params,
+      searchParams,
+    });
     return (
       <html
         lang={match.params.lang ?? this.#i18n.defaultLocale}
@@ -895,4 +1001,4 @@ class RscRenderer {
   }
 }
 
-new RscRenderer().start();
+if (import.meta.main) new RscRenderer().start();