akanjs 2.1.1 → 2.1.2-rc.1

package/server/rscWorker.tsx

@@ -1,4 +1,4 @@
-import type { AkanNotFoundError, AkanRedirectError, PathRoute } from "akanjs/client";
+import type { AkanNotFoundError, AkanRedirectError, LayoutFallbackRoute, PathRoute } from "akanjs/client";
 import { type AkanI18nConfig, DEFAULT_AKAN_I18N, getBasePathFromPathname, Logger } from "akanjs/common";
 import { cookies, getRequest, getRequestTheme, requestStorage } from "akanjs/fetch";
 import type { ReactNode } from "react";
@@ -7,6 +7,7 @@ import type { ClientManifest } from "./artifact";
 import { ProcessMetricsCollector } from "./processMetricsCollector";
 import { RouteElementComposer } from "./routeElementComposer";
 import { type PagesContext, RouteTreeBuilder } from "./routeTreeBuilder";
+import { createSystemPageDocument, getSystemPageHomeHref } from "./systemPages";
 
 interface InitMsg {
   type: "init";
@@ -14,6 +15,7 @@ interface InitMsg {
   pagesBundlePath: string;
   pagesBundleBuildId: number;
   cssAssets?: Record<string, { cssUrl: string; cssRelPath: string }>;
+  basePaths?: string[];
   i18n?: AkanI18nConfig;
 }
 interface RenderMsg {
@@ -37,7 +39,10 @@ interface UpdateCssAssetsMsg {
   cssAssets: Record<string, { cssUrl: string; cssRelPath: string }>;
 }
 type InMsg = InitMsg | RenderMsg | ReloadMsg | UpdateCssAssetsMsg;
-type RenderControl = { type: "redirect"; location: string; method: "replace" | "push" } | { type: "not-found" };
+type RenderControl =
+  | { type: "redirect"; location: string; method: "replace" | "push" }
+  | { type: "not-found" }
+  | { type: "error"; error: unknown };
 
 interface RscRendererStats {
   renderCount: number;
@@ -94,7 +99,9 @@ class RscRenderer {
   readonly #logger = new Logger("scWorker");
   #clientManifest: ClientManifest = {};
   #pathRoutes: PathRoute[] = [];
+  #fallbackRoutes: LayoutFallbackRoute[] = [];
   #cssAssets: Record<string, { cssUrl: string; cssRelPath: string }> = {};
+  #basePaths: string[] = [];
   #i18n: AkanI18nConfig = DEFAULT_AKAN_I18N;
   #pagesBundlePath = "";
   #pagesBundleBuildId = 0;
@@ -159,6 +166,7 @@ class RscRenderer {
     try {
       this.#clientManifest = msg.clientManifest;
       this.#cssAssets = msg.cssAssets ?? {};
+      this.#basePaths = msg.basePaths ?? Object.keys(this.#cssAssets);
       this.#i18n = msg.i18n ?? DEFAULT_AKAN_I18N;
       this.#pagesBundlePath = msg.pagesBundlePath;
       this.#pagesBundleBuildId = msg.pagesBundleBuildId;
@@ -168,7 +176,9 @@ class RscRenderer {
       this.#logger.verbose(
         `init state pagesBundlePath=${msg.pagesBundlePath} buildId=${msg.pagesBundleBuildId} cssAssets=${Object.keys(this.#cssAssets).length} clientEntries=${Object.keys(msg.clientManifest).length}`,
       );
-      this.#pathRoutes = await this.#importPages(msg.pagesBundlePath, msg.pagesBundleBuildId);
+      const routes = await this.#importPages(msg.pagesBundlePath, msg.pagesBundleBuildId);
+      this.#pathRoutes = routes.pathRoutes;
+      this.#fallbackRoutes = routes.fallbackRoutes;
       this.#logger.verbose(`init complete in ${Date.now() - startedAt}ms`);
       this.#send({ type: "ready" });
     } catch (error) {
@@ -193,7 +203,7 @@ class RscRenderer {
       this.#logger.verbose(
         `reload state buildId=${msg.buildId} bundlePath=${nextPagesBundlePath} cssAssets=${Object.keys(nextCssAssets).length} clientEntries=${Object.keys(msg.clientManifest).length}`,
       );
-      const pathRoutes = await this.#importPages(nextPagesBundlePath, msg.buildId);
+      const routes = await this.#importPages(nextPagesBundlePath, msg.buildId);
       if (seq !== this.#reloadSeq) {
         this.#logger.verbose(`reload stale buildId=${msg.buildId} seq=${seq} latest=${this.#reloadSeq}`);
         return;
@@ -203,7 +213,8 @@ class RscRenderer {
       this.#pagesBundlePath = nextPagesBundlePath;
       this.#pagesBundleBuildId = msg.buildId;
       this.#stats.pagesBundleBuildId = msg.buildId;
-      this.#pathRoutes = pathRoutes;
+      this.#pathRoutes = routes.pathRoutes;
+      this.#fallbackRoutes = routes.fallbackRoutes;
       this.#routeStats.clear();
       this.#resultCache.clear();
       this.#logger.verbose(`reload complete buildId=${msg.buildId} in ${Date.now() - startedAt}ms`);
@@ -221,7 +232,10 @@ class RscRenderer {
     }
   }
 
-  async #importPages(bundlePath: string, buildId: number): Promise<PathRoute[]> {
+  async #importPages(
+    bundlePath: string,
+    buildId: number,
+  ): Promise<{ pathRoutes: PathRoute[]; fallbackRoutes: LayoutFallbackRoute[] }> {
     const specifier = `${bundlePath}?v=${buildId}`;
     this.#logger.verbose(`importing pages bundle ${specifier}`);
     const importStart = Date.now();
@@ -231,12 +245,13 @@ class RscRenderer {
     if (!pages) throw new Error(`pages export not found in ${specifier}`);
 
     const routeBuildStart = Date.now();
-    const pathRoutes = new RouteTreeBuilder(pages).build();
+    const routeTree = new RouteTreeBuilder(pages);
+    const pathRoutes = routeTree.build();
     const routeBuildMs = Date.now() - routeBuildStart;
     this.#logger.verbose(
       `pages imported in ${Date.now() - importStart}ms import=${importedAt - importStart}ms routeBuild=${routeBuildMs}ms routes=${pathRoutes.length} specifier=${specifier}`,
     );
-    return pathRoutes;
+    return { pathRoutes, fallbackRoutes: routeTree.getFallbackRoutes() };
   }
 
   async #handleRender(msg: RenderMsg): Promise<void> {
@@ -244,12 +259,18 @@ class RscRenderer {
     const startedAt = Date.now();
     this.#stats.renderCount += 1;
     this.#stats.inFlightRenderCount += 1;
+    const activeRoute: {
+      url: URL | null;
+      match: { pathRoute: PathRoute; params: Record<string, string> } | null;
+    } = { url: null, match: null };
     try {
       const request = new Request(url, { method, headers });
       await this.#runWithRequest(request, async () => {
         const urlObj = new URL(url);
+        activeRoute.url = urlObj;
         this.#stats.lastRenderedPath = urlObj.pathname;
         const match = RouteTreeBuilder.match(urlObj.pathname, this.#pathRoutes);
+        activeRoute.match = match;
         const routeId = match?.pathRoute.path ?? "__not_found__";
         this.#stats.lastRenderRouteId = routeId;
         this.#stats.lastRenderKind = match ? "route" : "not-found";
@@ -276,62 +297,67 @@ class RscRenderer {
           return;
         }
         const theme = cookies().get("theme")?.value;
-        const element = match ? await this.#renderMatched(urlObj, match, theme) : this.#renderNotFound(urlObj);
+        const element = match ? await this.#renderMatched(urlObj, match, theme) : await this.#renderNotFound(urlObj);
         this.#logger.verbose(`render[${requestId}] starting Flight stream`);
-        const controlRef: { current: RenderControl | null } = { current: null };
-        const stream = await renderToReadableStream(element, msg.clientManifest ?? this.#clientManifest, {
-          onError: (error) => {
-            if (isAkanRedirectError(error)) {
-              controlRef.current = { type: "redirect", location: error.location, method: error.method };
-              return error.digest;
-            }
-            if (isAkanNotFoundError(error)) {
-              controlRef.current = { type: "not-found" };
-              return error.digest;
-            }
-            return error instanceof Error ? error.message : String(error);
-          },
-        });
-        const reader = stream.getReader();
-        let chunks = 0;
-        let bytes = 0;
-        const buffered: Uint8Array[] = [];
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          if (controlRef.current) {
-            await reader.cancel();
-            break;
-          }
-          const chunk = value instanceof Uint8Array ? value : new Uint8Array(value as ArrayBufferLike);
-          chunks += 1;
-          bytes += chunk.byteLength;
-          buffered.push(chunk);
-        }
-        const control = controlRef.current;
+        const result = await this.#renderFlightElement(element, msg.clientManifest ?? this.#clientManifest);
+        const control = result.control;
         if (control) {
           this.#stats.lastRenderKind = control.type;
+          if (!match && control.type === "error") {
+            const systemResult = await this.#renderFlightElement(
+              this.#renderSystemNotFound(urlObj),
+              msg.clientManifest ?? this.#clientManifest,
+            );
+            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;
+            }
+          }
+          if (
+            match &&
+            control.type !== "redirect" &&
+            (await this.#trySendFallbackRender({
+              requestId,
+              kind: control.type,
+              route: match.pathRoute,
+              params: match.params,
+              searchParams: RouteTreeBuilder.parseSearchParams(urlObj.search),
+              pathname: urlObj.pathname,
+              url: urlObj,
+              error: control.type === "error" ? control.error : undefined,
+              clientManifest: msg.clientManifest ?? this.#clientManifest,
+            }))
+          ) {
+            return;
+          }
           this.#sendRenderControl(requestId, control);
           return;
         }
-        this.#stats.lastFlightBytes = bytes;
-        this.#stats.lastFlightChunks = chunks;
-        this.#stats.totalFlightBytes += bytes;
-        this.#stats.totalFlightChunks += chunks;
+        this.#stats.lastFlightBytes = result.bytes;
+        this.#stats.lastFlightChunks = result.chunks.length;
+        this.#stats.totalFlightBytes += result.bytes;
+        this.#stats.totalFlightChunks += result.chunks.length;
         this.#stats.lastRenderDurationMs = Date.now() - startedAt;
         const afterLoadedKeys = RouteTreeBuilder.getCacheStats().loadedModuleKeys;
         this.#stats.lastRenderLoadedModules = afterLoadedKeys.filter((key) => !beforeLoadedKeys.includes(key));
         this.#stats.lastRenderLoadedModuleDelta = this.#stats.lastRenderLoadedModules.length;
-        this.#recordRouteStats(routeId, bytes, this.#stats.lastRenderDurationMs);
+        this.#recordRouteStats(routeId, result.bytes, this.#stats.lastRenderDurationMs);
         const responseTheme = getRequestTheme();
         if (cacheKey)
-          this.#setCachedResult(cacheKey, { chunks: buffered, bytes, chunksCount: chunks, theme: responseTheme });
-        this.#send({ type: "meta", requestId, theme: responseTheme });
-        for (const chunk of buffered) {
+          this.#setCachedResult(cacheKey, {
+            chunks: result.chunks,
+            bytes: result.bytes,
+            chunksCount: result.chunks.length,
+            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=${chunks} bytes=${bytes} in ${Date.now() - startedAt}ms`,
+          `render[${requestId}] done chunks=${result.chunks.length} bytes=${result.bytes} in ${Date.now() - startedAt}ms`,
         );
         this.#send({ type: "end", requestId });
       });
@@ -345,12 +371,49 @@ class RscRenderer {
       if (isAkanNotFoundError(error)) {
         this.#stats.lastRenderKind = "not-found";
         this.#logger.verbose(`render[${requestId}] not-found`);
+        const fallbackUrl = activeRoute.url;
+        const fallbackMatch = activeRoute.match;
+        if (
+          fallbackUrl &&
+          fallbackMatch &&
+          (await this.#trySendFallbackRender({
+            requestId,
+            kind: "not-found",
+            route: fallbackMatch.pathRoute,
+            params: fallbackMatch.params,
+            searchParams: RouteTreeBuilder.parseSearchParams(fallbackUrl.search),
+            pathname: fallbackUrl.pathname,
+            url: fallbackUrl,
+            clientManifest: msg.clientManifest ?? this.#clientManifest,
+          }))
+        ) {
+          return;
+        }
         this.#send({ type: "not-found", requestId });
         return;
       }
       this.#logger.error(
         `render[${requestId}] failed url=${url}: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`,
       );
+      const fallbackUrl = activeRoute.url;
+      const fallbackMatch = activeRoute.match;
+      if (
+        fallbackUrl &&
+        fallbackMatch &&
+        (await this.#trySendFallbackRender({
+          requestId,
+          kind: "error",
+          route: fallbackMatch.pathRoute,
+          params: fallbackMatch.params,
+          searchParams: RouteTreeBuilder.parseSearchParams(fallbackUrl.search),
+          pathname: fallbackUrl.pathname,
+          url: fallbackUrl,
+          error,
+          clientManifest: msg.clientManifest ?? this.#clientManifest,
+        }))
+      ) {
+        return;
+      }
       this.#send({
         type: "error",
         requestId,
@@ -403,12 +466,107 @@ class RscRenderer {
     this.#send({ type: "metrics", metrics });
   }
 
+  async #renderFlightElement(
+    element: ReactNode,
+    clientManifest: ClientManifest,
+  ): Promise<{ chunks: Uint8Array[]; bytes: number; control: RenderControl | null }> {
+    const controlRef: { current: RenderControl | null } = { current: null };
+    const stream = await renderToReadableStream(element, clientManifest, {
+      onError: (error) => {
+        if (isAkanRedirectError(error)) {
+          controlRef.current = { type: "redirect", location: error.location, method: error.method };
+          return error.digest;
+        }
+        if (isAkanNotFoundError(error)) {
+          controlRef.current = { type: "not-found" };
+          return error.digest;
+        }
+        controlRef.current = { type: "error", error };
+        return error instanceof Error ? error.message : String(error);
+      },
+    });
+    const reader = stream.getReader();
+    let bytes = 0;
+    const chunks: Uint8Array[] = [];
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      if (controlRef.current) {
+        await reader.cancel();
+        break;
+      }
+      const chunk = value instanceof Uint8Array ? value : new Uint8Array(value as ArrayBufferLike);
+      bytes += chunk.byteLength;
+      chunks.push(chunk);
+    }
+    return { chunks, bytes, control: controlRef.current };
+  }
+
+  async #trySendFallbackRender({
+    requestId,
+    kind,
+    route,
+    params,
+    searchParams,
+    pathname,
+    url,
+    error,
+    clientManifest,
+  }: {
+    requestId: string;
+    kind: "not-found" | "error";
+    route: PathRoute | LayoutFallbackRoute;
+    params: Record<string, string>;
+    searchParams: Record<string, string | string[]>;
+    pathname: string;
+    url: URL;
+    error?: unknown;
+    clientManifest: ClientManifest;
+  }): Promise<boolean> {
+    try {
+      const element = await this.#renderFallbackDocument({
+        kind,
+        route,
+        params,
+        searchParams,
+        pathname,
+        url,
+        error: kind === "error" ? RscRenderer.#errorForFallback(error) : undefined,
+        digest: kind === "error" ? "AKAN_RENDER_ERROR" : undefined,
+      });
+      if (!element) return false;
+      const result = await this.#renderFlightElement(element, clientManifest);
+      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.totalFlightBytes += result.bytes;
+      this.#stats.totalFlightChunks += result.chunks.length;
+      return true;
+    } catch (fallbackError) {
+      this.#logger.error(
+        `render[${requestId}] custom ${kind} fallback failed: ${
+          fallbackError instanceof Error ? (fallbackError.stack ?? fallbackError.message) : String(fallbackError)
+        }`,
+      );
+      return false;
+    }
+  }
+
   #sendRenderControl(requestId: string, control: RenderControl): void {
     if (control.type === "redirect") {
       this.#logger.verbose(`render[${requestId}] redirect ${control.location}`);
       this.#send({ type: "redirect", requestId, location: control.location, method: control.method });
       return;
     }
+    if (control.type === "error") {
+      const message = control.error instanceof Error ? control.error.message : String(control.error);
+      this.#logger.verbose(`render[${requestId}] error`);
+      this.#send({ type: "error", requestId, message });
+      return;
+    }
     this.#logger.verbose(`render[${requestId}] not-found`);
     this.#send({ type: "not-found", requestId });
   }
@@ -493,6 +651,55 @@ class RscRenderer {
     return fn();
   }
 
+  async #renderFallbackDocument({
+    kind,
+    route,
+    params,
+    searchParams,
+    pathname,
+    url,
+    error,
+    digest,
+  }: {
+    kind: "not-found" | "error";
+    route: PathRoute | LayoutFallbackRoute;
+    params: Record<string, string>;
+    searchParams: Record<string, string | string[]>;
+    pathname: string;
+    url: URL;
+    error?: unknown;
+    digest?: string;
+  }): Promise<ReactNode | null> {
+    const body = await RouteElementComposer.composeFallback({
+      kind,
+      route,
+      params,
+      searchParams,
+      pathname,
+      error,
+      digest,
+    });
+    if (!body) return null;
+    const routeHead = "resolveHead" in route ? await route.resolveHead?.({ params, searchParams }) : undefined;
+    const theme = cookies().get("theme")?.value;
+    return (
+      <html
+        lang={params.lang ?? RscRenderer.#getLocale(pathname, this.#i18n)}
+        {...(theme ? { "data-theme": theme } : { suppressHydrationWarning: true })}
+      >
+        <head key="head">
+          <meta key="charset" charSet="utf-8" />
+          <meta key="viewport" name="viewport" content="width=device-width, initial-scale=1" />
+          <meta key="robots" name="robots" content="noindex" />
+          {routeHead ?? this.#renderDefaultHead()}
+          {this.#renderLocaleAlternates(url)}
+          {this.#renderStylesheet(pathname)}
+        </head>
+        <body key="body">{body}</body>
+      </html>
+    );
+  }
+
   async #renderMatched(
     url: URL,
     match: { pathRoute: PathRoute; params: Record<string, string> },
@@ -525,20 +732,41 @@ class RscRenderer {
     );
   }
 
-  #renderNotFound(url: URL): ReactNode {
-    return (
-      <html lang={this.#i18n.defaultLocale}>
-        <head key="head">
-          <meta key="charset" charSet="utf-8" />
-          <title key="title">Not Found</title>
-          {this.#renderStylesheet(url.pathname)}
-        </head>
-        <body key="body">
-          <h1 key="title">404</h1>
-          <p key="message">No route matched: {url.pathname}</p>
-        </body>
-      </html>
-    );
+  async #renderNotFound(url: URL): Promise<ReactNode> {
+    const matchedFallback = RouteTreeBuilder.matchFallback(url.pathname, this.#fallbackRoutes);
+    if (matchedFallback) {
+      try {
+        const fallback = await this.#renderFallbackDocument({
+          kind: "not-found",
+          route: matchedFallback.fallbackRoute,
+          params: matchedFallback.params,
+          searchParams: RouteTreeBuilder.parseSearchParams(url.search),
+          pathname: url.pathname,
+          url,
+        });
+        if (fallback) return fallback;
+      } catch (error) {
+        this.#logger.error(
+          `custom unmatched not-found fallback failed: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`,
+        );
+      }
+    }
+    return this.#renderSystemNotFound(url);
+  }
+
+  #renderSystemNotFound(url: URL): ReactNode {
+    return createSystemPageDocument({
+      kind: "not-found",
+      pathname: url.pathname,
+      lang: RscRenderer.#getLocale(url.pathname, this.#i18n),
+      homeHref: getSystemPageHomeHref({
+        pathname: url.pathname,
+        i18n: this.#i18n,
+        basePaths: this.#basePaths,
+        headerBasePath: getRequest()?.headers.get("x-base-path"),
+      }),
+      stylesheetHref: this.#getStylesheetHref(url.pathname),
+    });
   }
 
   #renderDefaultHead(): ReactNode {
@@ -564,14 +792,23 @@ class RscRenderer {
   }
 
   #renderStylesheet(pathname: string): ReactNode {
+    const cssUrl = this.#getStylesheetHref(pathname);
+    if (!cssUrl) return null;
+    return <link key="stylesheet" rel="stylesheet" href={cssUrl} precedence="default" data-akan-css="active" />;
+  }
+
+  #getStylesheetHref(pathname: string): string | null {
     const basePath = getBasePathFromPathname(pathname, {
       basePaths: Object.keys(this.#cssAssets),
       i18n: this.#i18n,
       headerBasePath: getRequest()?.headers.get("x-base-path"),
     });
-    const cssUrl = this.#cssAssets[basePath ?? ""]?.cssUrl;
-    if (!cssUrl) return null;
-    return <link key="stylesheet" rel="stylesheet" href={cssUrl} precedence="default" data-akan-css="active" />;
+    return this.#cssAssets[basePath ?? ""]?.cssUrl ?? null;
+  }
+
+  static #getLocale(pathname: string, i18n: AkanI18nConfig): string {
+    const [segment] = pathname.split("/").filter(Boolean);
+    return segment && i18n.locales.includes(segment) ? segment : i18n.defaultLocale;
   }
 
   static #parsePositiveIntEnv(name: string): number | null {
@@ -597,6 +834,11 @@ class RscRenderer {
       .every((name) => name === "theme" || name.startsWith("akan_public_"));
   }
 
+  static #errorForFallback(error: unknown): unknown {
+    if (process.env.NODE_ENV !== "production") return error;
+    return undefined;
+  }
+
   static #getPublicRequestUrl(url: URL): URL {
     const publicUrl = new URL(url);
     const req = getRequest();

package/server/rscWorkerHost.ts

@@ -11,7 +11,7 @@ interface RscPending {
   onChunk: (data: Uint8Array) => void;
   onEnd: () => void;
   onError: (message: string) => void;
-  onMeta?: (meta: { theme?: AkanTheme }) => void;
+  onMeta?: (meta: { theme?: AkanTheme; status?: number }) => void;
   onRedirect?: (location: string, method: RscRedirectMethod) => void;
   onNotFound?: () => void;
 }
@@ -19,7 +19,7 @@ interface RscPending {
 export type RscRedirectMethod = "replace" | "push";
 
 export type RscRenderResult =
-  | { type: "stream"; stream: ReadableStream<Uint8Array>; theme?: AkanTheme }
+  | { type: "stream"; stream: ReadableStream<Uint8Array>; theme?: AkanTheme; status?: number }
   | { type: "redirect"; location: string; method: RscRedirectMethod }
   | { type: "not-found" };
 
@@ -27,7 +27,7 @@ type RscInMsg =
   | { type: "hello" }
   | { type: "ready" }
   | { type: "reloaded"; buildId: number }
-  | { type: "meta"; requestId: string; theme?: AkanTheme }
+  | { type: "meta"; requestId: string; theme?: AkanTheme; status?: number }
   | { type: "chunk"; requestId: string; data: Uint8Array }
   | { type: "end"; requestId: string }
   | { type: "redirect"; requestId: string; location: string; method?: RscRedirectMethod }
@@ -89,6 +89,7 @@ export class RscWorker {
   #pagesBundlePath: string;
   #pagesBundleBuildId: number;
   #cssAssets: Record<string, CssAsset>;
+  #basePaths: string[];
   #i18n: AkanI18nConfig;
   #resolveReady!: () => void;
   #rejectReady!: (err: Error) => void;
@@ -116,6 +117,7 @@ export class RscWorker {
     this.#pagesBundlePath = artifact.pagesBundlePath;
     this.#pagesBundleBuildId = artifact.pagesBundleBuildId;
     this.#cssAssets = artifact.cssAssets ?? {};
+    this.#basePaths = artifact.basePaths ?? [];
     this.#i18n = artifact.i18n ?? DEFAULT_AKAN_I18N;
     this.#restartOpts = { baseDelayMs: 200, maxDelayMs: 30_000, maxAttempts: undefined };
     this.ready = new Promise<void>((resolve, reject) => {
@@ -178,17 +180,19 @@ export class RscWorker {
     let settled = false;
     let stream!: ReadableStream<Uint8Array>;
     let theme: AkanTheme | undefined;
+    let status: number | undefined;
     const result = new Promise<RscRenderResult>((resolve, reject) => {
       stream = new ReadableStream<Uint8Array>({
         start: (controller) => {
           const settleStream = () => {
             if (settled) return;
             settled = true;
-            resolve({ type: "stream", stream, theme });
+            resolve({ type: "stream", stream, theme, status });
           };
           this.#pending.set(requestId, {
             onMeta: (meta) => {
               theme = meta.theme;
+              status = meta.status;
               settleStream();
             },
             onChunk: (data) => {
@@ -375,6 +379,7 @@ export class RscWorker {
           pagesBundlePath: this.#pagesBundlePath,
           pagesBundleBuildId: this.#pagesBundleBuildId,
           cssAssets: this.#cssAssets,
+          basePaths: this.#basePaths,
           i18n: this.#i18n,
         });
         return;
@@ -395,7 +400,7 @@ export class RscWorker {
         this.#pending.get(message.requestId)?.onChunk(message.data);
         return;
       case "meta":
-        this.#pending.get(message.requestId)?.onMeta?.({ theme: message.theme });
+        this.#pending.get(message.requestId)?.onMeta?.({ theme: message.theme, status: message.status });
         return;
       case "end":
         this.#resolvePending(message.requestId, (p) => p.onEnd());