akanjs 3.1.0-rc.26 → 3.1.0-rc.27

package/README.ko.md

@@ -22,7 +22,7 @@
 ```text
 Akan.js(https://akanjs.com) 워크스페이스를 새로 만들어 줘.
 
-1. Bun 1.4 이상이 설치돼 있는지 확인해 줘(`bun --version`). 없거나 버전이 낮으면 https://bun.sh 안내대로 설치하거나 업그레이드해 줘.
+1. Bun 1.4.4 이상이 설치돼 있는지 확인해 줘(`bun --version`). 없거나 버전이 낮으면 https://bun.sh 안내대로 설치하거나 업그레이드해 줘.
 2. 워크스페이스 이름과 첫 앱 이름을 물어봐 줘. 짧은 영문 소문자로, 아래에 적어 뒀다면 그걸 쓰면 돼.
 3. 이 디렉터리에서 `bunx create-akan-workspace@latest <워크스페이스> --app <앱>`을 실행해 줘. akan CLI를 전역으로 설치하고, ./<워크스페이스>를 만들어 의존성까지 설치해.
 4. ./<워크스페이스> 안에서 `akan start <앱>`으로 개발 서버를 백그라운드에 띄우고, 출력된 주소(기본 http://localhost:8282)가 열리는지 확인해 줘.

package/README.md

@@ -22,7 +22,7 @@ or let the agent ask.
 ```text
 Set up a new Akan.js workspace for me (https://akanjs.com).
 
-1. Check that Bun 1.4 or newer is installed (`bun --version`). If it isn't, install or upgrade it as https://bun.sh describes.
+1. Check that Bun 1.4.4 or newer is installed (`bun --version`). If it isn't, install or upgrade it as https://bun.sh describes.
 2. Ask me for a workspace name and a first app name, short and lowercase, unless I wrote them below.
 3. In this directory, run `bunx create-akan-workspace@latest <workspace> --app <app>`. It installs the akan CLI globally, creates ./<workspace> and installs its dependencies.
 4. Inside ./<workspace>, start the dev server in the background with `akan start <app>` and check that the URL it prints (http://localhost:8282 by default) loads.

package/client/href.ts

@@ -25,6 +25,14 @@ export class Href {
     return /^https?:/i.test(href);
   }
 
+  /** Whether an http(s) href resolves, against `base`, to another origin than `base`'s. Any other href stays a path in
+   * the app; no base, as outside a request, leaves for anywhere. */
+  static leavesOrigin(href: string, base: string | undefined): boolean {
+    if (!Href.hasWebScheme(href)) return false;
+    const origin = base === undefined ? undefined : Href.#parse(base)?.origin;
+    return !origin || Href.#parse(href, base)?.origin !== origin;
+  }
+
   /** Canonical absolute URL for an external href: follows the browser on an http(s) document base; on a native
    * `app://` base an absolute URL resolves as written and a network path resolves against https:. */
   static toExternalUrl(href: string, base: string): string {

package/client/router.ts

@@ -12,6 +12,9 @@ export interface RouteOptions {
    * navigation.
    */
   shallow?: boolean;
+  /** Lets an absolute URL on another origin through; without it the router refuses one, so a `?redirect=` handed on
+   * unchecked cannot send a visitor off-site. */
+  external?: boolean;
 }
 export interface RouteManifest {
   routes: string[];
@@ -55,6 +58,8 @@ export type RedirectStatus = 303 | 307 | 308;
 export interface RedirectOptions {
   method?: RedirectMethod;
   status?: RedirectStatus;
+  /** As `RouteOptions.external`; a target it refuses redirects to the index path instead. */
+  external?: boolean;
 }
 
 export class AkanRedirectError extends Error {
@@ -85,6 +90,16 @@ function getServerRequestContext() {
   };
 }
 
+const getServerPublicOrigin = () => {
+  const { getRequest, headers } = getServerRequestContext();
+  const h = headers();
+  const url = getRequest()?.url;
+  const host = h.get("x-forwarded-host")?.split(",")[0]?.trim() ?? h.get("host");
+  const proto = h.get("x-forwarded-proto")?.split(",")[0]?.trim();
+  if (!host) return url;
+  return `${proto ?? (url ? new URL(url).protocol.replace(":", "") : "https")}://${host}`;
+};
+
 const getConfiguredBasePaths = () => new Set(parseBasePaths(process.env.AKAN_PUBLIC_BASE_PATHS));
 
 const shouldExposeBasePath = () => getEnv().operationMode === "local";
@@ -306,7 +321,7 @@ class Router {
   }
   #withCsrRuntimeSearchParams(href: string) {
     const currentSearch = new URLSearchParams(csrLocation.search);
-    if (currentSearch.get("csr") !== "true") return href;
+    if (currentSearch.get("csr") !== "true" || Href.hasWebScheme(href)) return href;
 
     const [hrefWithoutHash, hash = ""] = href.split("#");
     const [pathname, search = ""] = hrefWithoutHash.split("?");
@@ -391,6 +406,7 @@ class Router {
   }
   push(href: string, routeOptions?: RouteOptions) {
     this.#checkInitialized();
+    if (this.#refusesOffsite("push", href, routeOptions)) return undefined as never;
     this.#navigations += 1;
     this.#track(this.#instance.push(href, routeOptions));
     this.#rememberHistoryState("push");
@@ -399,6 +415,7 @@ class Router {
   }
   replace(href: string, routeOptions?: RouteOptions) {
     this.#checkInitialized();
+    if (this.#refusesOffsite("replace", href, routeOptions)) return undefined as never;
     this.#navigations += 1;
     this.#track(this.#instance.replace(href, routeOptions));
     this.#rememberHistoryState("replace");
@@ -410,6 +427,20 @@ class Router {
   navigation(): Promise<void> {
     return this.#navigation;
   }
+  #leavesOrigin(href: string, external?: boolean) {
+    if (external || !Href.hasWebScheme(href)) return false;
+    return Href.leavesOrigin(
+      href,
+      getEnv().side === "server" ? getServerPublicOrigin() : globalThis.window?.location?.href,
+    );
+  }
+  #refusesOffsite(method: "push" | "replace", href: string, routeOptions?: RouteOptions) {
+    if (!this.#leavesOrigin(href, routeOptions?.external)) return false;
+    const message = `router.${method}(${href}) leaves this origin and was refused; pass { external: true } to leave on purpose`;
+    Logger.warn(message);
+    this.#track(Promise.reject(new Error(message)));
+    return true;
+  }
   #track(result: void | Promise<void>) {
     this.#navigation = Promise.resolve(result);
     
@@ -456,9 +487,16 @@ class Router {
   navigationCount(): number {
     return this.#navigations;
   }
-  redirect(href: string, options: RedirectOptions = {}): never {
+  redirect(target: string, options: RedirectOptions = {}): never {
     const method = options.method ?? "replace";
     const status = options.status ?? 307;
+    
+    const offsite = this.#leavesOrigin(target, options.external);
+    if (offsite)
+      Logger.warn(
+        `router.redirect(${target}) leaves this origin, so it redirects to ${this.#indexPath} instead; pass { external: true } to leave on purpose`,
+      );
+    const href = offsite ? this.#indexPath : target;
     if (getEnv().side === "server") {
       const { getRequest, headers: requestHeaders } = getServerRequestContext();
       const h = requestHeaders();

package/common/Logger.ts

@@ -89,7 +89,9 @@ const consoleMethodMap = {
 const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
 
 const secretKey =
-  /password|passwd|passphrase|^pass$|pwd|token|jwt|authorization|cookie|secret|api[-_]?key|private[-_]?key|access[-_]?key|auth[-_]?key|hash[-_]?key|(?:signing|encryption|master|session)[-_]?key|webhook|cred|dsn$|connection[-_]?string|iap[-_]?verify|service[-_]?account/i;
+  /password|passwd|passphrase|^pass$|pwd|token|jwt|authorization|cookie|secret|api[-_]?key|private[-_]?key|access[-_]?key|auth[-_]?key|hash[-_]?key|(?:signing|encryption|master|session)[-_]?key|webhook|credential|dsn$|connection[-_]?string|iap[-_]?verify|service[-_]?account/i;
+
+const credWord = /[cC]reds?(?![a-z])|CREDS?(?![A-Z])/;
 
 const envValue = (key: string): string | undefined => (typeof process === "undefined" ? undefined : process.env?.[key]);
 
@@ -174,19 +176,19 @@ export class Logger {
   static inlineData(value: unknown, max = 500): string {
     let text: string;
     try {
-      text = JSON.stringify(value, (key, val) => (key && secretKey.test(key) ? "[redacted]" : val)) ?? "";
+      text = JSON.stringify(value, (key, val) => (key && Logger.isSecretKey(key) ? "[redacted]" : val)) ?? "";
     } catch {
       text = "[unserializable]";
     }
     return text.length > max ? `${text.slice(0, max)}…` : text;
   }
   static isSecretKey(name: string) {
-    return secretKey.test(name);
+    return secretKey.test(name) || credWord.test(name);
   }
   static redactAttrs(attrs: LogAttrs): LogAttrs {
     let redacted: LogAttrs | null = null;
     for (const key of Object.keys(attrs)) {
-      if (!secretKey.test(key)) continue;
+      if (!Logger.isSecretKey(key)) continue;
       redacted ??= { ...attrs };
       redacted[key] = "[redacted]";
     }

package/fetch/client/httpClient.ts

@@ -1,6 +1,11 @@
-import { Backoff, isRecord, type RetryPolicy } from "akanjs/common";
+import { Backoff, isRecord, Logger, type RetryPolicy } from "akanjs/common";
 import type { HttpMutationMethod, SerializedArg } from "akanjs/signal";
-import { type ErrorConstructor, type RestoredError, restoreRemoteError } from "./remoteError";
+import {
+  type ErrorConstructor,
+  type ErrorResponsePayload,
+  type RestoredError,
+  restoreRemoteError,
+} from "./remoteError";
 
 export interface HttpClientOptions {
   headers?: Record<string, string>;
@@ -42,6 +47,7 @@ const transportDetailLimit = 200;
 const DEFAULT_TIMEOUT_MS = 30_000;
 
 export class HttpClient {
+  static readonly #logger = new Logger("HttpClient");
   readonly baseUrl: string;
   #headers: Record<string, string>;
   #timeout?: number | false;
@@ -166,11 +172,11 @@ export class HttpClient {
 
   async #requestOnce<Returns>(url: string, init: RequestInit, deadline: number): Promise<Returns> {
     const res = await this.#fetch(url, this.#withDeadline(init, deadline));
-    const body = await this.#readBody(res);
+    const body = await this.#readBody(url, res);
     if (res.ok) return body as Returns;
     
     if (res.status in transportErrorKeyMap && !HttpClient.#namesErrorKey(body))
-      throw this.#transportError(res, JSON.stringify(body));
+      throw this.#transportError(url, res, JSON.stringify(body));
     throw this.#restoreError(body, res.status);
   }
 
@@ -197,21 +203,21 @@ export class HttpClient {
       if (error instanceof Error && error.name === "TimeoutError")
         throw this.#restoreError({ error: transportErrorKeyMap[408], data: { status: 408 } }, 408);
       if (error instanceof Error && error.name === "AbortError") throw error;
-      throw this.#restoreError({ error: serverUnreachableKey, details: String(error) }, 503);
+      throw this.#transportFailure(url, { error: serverUnreachableKey, details: String(error) }, 503);
     }
   }
 
-  async #readBody(res: Response) {
+  async #readBody(url: string, res: Response) {
     if (jsonContentType.test(res.headers.get("content-type") ?? "")) {
       try {
         return (await res.json()) as unknown;
       } catch (error) {
-        throw this.#transportError(res, String(error));
+        throw this.#transportError(url, res, String(error));
       }
     }
     const raw = await res.text();
     const parsed = HttpClient.#parseJson(raw);
-    if (parsed === undefined) throw this.#transportError(res, raw);
+    if (parsed === undefined) throw this.#transportError(url, res, raw);
     return parsed;
   }
 
@@ -223,11 +229,33 @@ export class HttpClient {
     }
   }
 
-  #transportError(res: Response, detail: string): RestoredError {
+  #transportError(url: string, res: Response, detail: string): RestoredError {
     const { status } = res;
     const error = transportErrorKeyMap[status as keyof typeof transportErrorKeyMap] ?? unexpectedResponseKey;
     const data = status === 429 ? { status, seconds: HttpClient.#retryAfterSeconds(res) } : { status };
-    return this.#restoreError({ error, data, details: detail.slice(0, transportDetailLimit) }, status);
+    return this.#transportFailure(url, { error, data, details: detail.slice(0, transportDetailLimit) }, status);
+  }
+
+  #transportFailure(url: string, body: ErrorResponsePayload, status: number): RestoredError {
+    if (typeof window === "undefined")
+      HttpClient.#logger.warn(`${body.error} from ${HttpClient.#originAndPath(url)}: ${JSON.stringify(body.details)}`);
+    const error = this.#restoreError(body, status);
+    const toJSON = error.toJSON?.bind(error);
+    if (toJSON)
+      error.toJSON = () => {
+        const { details: _local, ...wire } = toJSON();
+        return wire;
+      };
+    return error;
+  }
+
+  static #originAndPath(url: string) {
+    try {
+      const { origin, pathname } = new URL(url);
+      return `${origin}${pathname}`;
+    } catch {
+      return url.split("?")[0];
+    }
   }
 
   static #retryAfterSeconds(res: Response): number {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.1.0-rc.26",
+  "version": "3.1.0-rc.27",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -262,7 +262,7 @@
     "react-dom": "19.3.1",
     "react-icons": "^5.7.0",
     "react-refresh": "^0.19.0",
-    "react-server-dom-webpack": "^19.3.1",
+    "react-server-dom-webpack": "19.3.1",
     "react-spring": "^10.0.4",
     "scheduler": "^0.28.0",
     "tailwind-scrollbar": "^4.0.2",

package/server/akanApp.ts

@@ -109,7 +109,7 @@ export class AkanApp {
   readonly #devHosted = process.env.AKAN_COMMAND_TYPE === "start";
   readonly #healthTimeoutMs = AkanApp.#parseHealthTimeoutMs();
   readonly #upstreamWaitMs = AkanApp.#parseUpstreamWaitMs();
-  /** Child stderr is bundler/runtime noise the gateway cannot act on; it still reaches the rotating log file. */
+  /** Child stderr is mostly bundler/runtime noise, kept to the log file; with none it may be a crash's only trace. */
   readonly #printChildStderr = process.env.AKAN_CHILD_STDERR === "1";
   readonly #serverPath: string;
   readonly #artifactDir: string;
@@ -1337,7 +1337,7 @@ export class AkanApp {
       return;
     }
     const prefixedLine = `[child:${idx} ${role}] [${type}] ${line}`;
-    if (type === "stdout" || this.#printChildStderr) process[type].write(prefixedLine);
+    if (type === "stdout" || this.#printChildStderr || !this.#logWriter) process[type].write(prefixedLine);
     this.#logWriter?.write(`${idx}-${role}`, AkanApp.#stripAnsi(prefixedLine));
   }
 

package/server/akanServer.ts

@@ -66,7 +66,10 @@ export interface AkanServerProps extends AkanLibProps {
 
 export interface AkanServerOptions {
   openapi?: boolean;
-  /** `/mcp` is mounted by default; `false` takes it off, and the object form carries the rest of its settings. */
+  /**
+   * `/mcp` is mounted by default, on an edge server only when asked for here or by `AKAN_MCP=true`; `false` takes it
+   * off, and the object form carries the rest of its settings.
+   */
   mcp?: boolean | McpServerOption;
   /** Boot only these modules and what they reach; omitted or empty mounts every enabled module. */
   modules?: string[];
@@ -107,13 +110,15 @@ export interface McpServerOption {
   /** Characters a page prompt may attach before its lists are cut; 60,000 by default. `AKAN_MCP_PROMPT_BUDGET`. */
   promptBudget?: number;
   /**
-   * MCP Apps: a `.prompt()` page is a tool as well, whose result a host speaking the extension renders from the CSR
-   * shell; an endpoint kept off the shelf by `mcp: false` stays callable by that view. `true` by default. `AKAN_MCP_APPS`.
+   * MCP Apps: each `.app()` is a read-only tool whose result a host speaking the extension draws with that app's own
+   * view, and a `.prompt()` page a text tool; an endpoint kept off the shelf by `mcp: false` stays callable by a view.
+   * `false` publishes no page tools. `true` by default. `AKAN_MCP_APPS`.
    */
   apps?: boolean;
   /**
-   * Speak the modern `2026-07-28` revision (`server/discover`) beside the legacy ones. On unless MCP Apps renders views,
-   * since claude.ai renders a view only for a server it reached through `initialize`. `AKAN_MCP_MODERN`.
+   * Speak the modern `2026-07-28` revision (`server/discover`) beside the legacy ones. On unless the build serves views
+   * and a page declares `.app()`, since claude.ai renders a view only for a server it reached through `initialize`.
+   * `AKAN_MCP_MODERN`.
    */
   modern?: boolean;
 }

package/server/mcp/McpDispatcher.ts

@@ -72,7 +72,8 @@ export class McpDispatcher {
   }
 
   static #restorable(error: unknown, status: number | undefined) {
-    if (!status || status >= 500 || status === 401 || status === 403) return null;
+    if (!status || status >= 500) return null;
+    if (status === 401 || status === 403) return { statusCode: status };
     return isExceptionLike(error) ? error.toJSON() : null;
   }
 

package/server/resolver/signal.resolver.ts

@@ -448,6 +448,8 @@ export class SignalResolver {
             ._addInternalArgs(sliceInfo.internalArgs)
             .exec(async function (this: any, ...requestArgs: any) {
               const args = requestArgs.slice(0, argLength);
+              
+              SignalResolver.#assertNotPaused(liveKey, sliceInfo, args);
               const internalArgs = requestArgs.slice(argLength);
               return assertSliceQuery(
                 await sliceInfo.execFn?.apply(this, [...args, ...internalArgs, documentQueryHelper]),
@@ -542,15 +544,10 @@ export class SignalResolver {
       }
     }
   }
-  static #assertNotPaused(
-    key: string,
-    liveOption: LiveEndpointOption,
-    endpointInfo: EndpointInfo,
-    context: SignalContext,
-  ) {
-    for (const name of liveOption.pauseOn) {
-      const idx = endpointInfo.args.findIndex((arg) => arg.name === name);
-      if (idx < 0 || context.args[idx] == null) continue;
+  static #assertNotPaused(key: string, sliceInfo: SliceInfo, args: unknown[]) {
+    for (const name of sliceInfo.liveOption?.pauseOn ?? []) {
+      const idx = sliceInfo.args.findIndex((arg) => arg.name === name);
+      if (idx < 0 || args[idx] == null) continue;
       throw new Error(
         `Live room "${key}" is paused while "${name}" carries a value: the slice declared it in ` +
           `.live({ pauseOn }), so this window updates by refetching instead of subscribing.`,
@@ -696,11 +693,10 @@ export class SignalResolver {
                 ).init();
                 const liveOption = endpointInfo.signalOption.live;
                 
+                const query = subscribe ? await context.exec() : null;
+                
                 const requestRoomId = context.getRoomId(key);
                 if (subscribe) {
-                  
-                  if (liveOption) SignalResolver.#assertNotPaused(key, liveOption, endpointInfo, context);
-                  const query = await context.exec();
                   const isClosed = SignalResolver.#closedWs.has(ws);
                   
                   if (isClosed || SignalResolver.#pendingSubscribes.isLeft(ws, requestRoomId, arrival)) {
@@ -752,19 +748,19 @@ export class SignalResolver {
                   return ack;
                 }
                 SignalResolver.#pendingSubscribes.leave(ws, requestRoomId, arrival);
-                if (liveOption) await context.resolveInternalArgs();
-                const roomId = liveOption ? context.getLiveRoomId(key) : requestRoomId;
-                ws.unsubscribe(roomId);
-                const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws);
-                const roomCtx = roomCtxMap?.get(roomId);
-                if (roomCtxMap && roomCtx) {
-                  await SignalResolver.#runLifecycleHandlers([roomCtx], ["unsubscribe"]);
-                  roomCtxMap.delete(roomId);
-                  if (roomCtxMap.size === 0) SignalResolver.#liveWsPubsubRoomCtx.delete(ws);
-                  SignalResolver.#leaveRoom(roomId, liveOption ? live : undefined);
-                  websocket.leaveRoom(ws, roomId);
+                
+                const heldRooms = [...(SignalResolver.#liveWsPubsubRoomCtx.get(ws) ?? [])].filter(
+                  ([, roomCtx]) => roomCtx.getRoomId(roomCtx.key) === requestRoomId,
+                );
+                for (const [roomId, roomCtx] of heldRooms) {
+                  SignalResolver.#leaveWsRoom(ws, roomId, roomCtx, websocket, liveOption ? live : undefined);
                   SignalResolver.logger.verbose(`WebSocket unsubscribed from room ${roomId}`);
                 }
+                await SignalResolver.#runLifecycleHandlers(
+                  heldRooms.map(([, roomCtx]) => roomCtx),
+                  ["unsubscribe"],
+                );
+                const roomId = heldRooms[0]?.[0] ?? requestRoomId;
                 const ack: WebsocketSubscribeAck = { type: "sub", roomId, requestRoomId, subscribe };
                 return ack;
               });
@@ -850,17 +846,30 @@ export class SignalResolver {
     const revokedRooms: string[] = [];
     for (const [roomId, roomCtx] of [...roomCtxMap]) {
       if (await roomCtx.authorize()) continue;
-      ws.unsubscribe(roomId);
-      await SignalResolver.#runLifecycleHandlers([roomCtx], ["unsubscribe"]);
-      roomCtxMap.delete(roomId);
-      SignalResolver.#leaveRoom(roomId, live);
-      websocket.leaveRoom(ws, roomId);
+      if (!SignalResolver.#leaveWsRoom(ws, roomId, roomCtx, websocket, live)) continue;
       revokedRooms.push(roomId);
       SignalResolver.logger.verbose(`WebSocket lost access to room ${roomId}; unsubscribed`);
+      await SignalResolver.#runLifecycleHandlers([roomCtx], ["unsubscribe"]);
     }
-    if (roomCtxMap.size === 0) SignalResolver.#liveWsPubsubRoomCtx.delete(ws);
     return revokedRooms;
   }
+  
+  static #leaveWsRoom(
+    ws: Bun.ServerWebSocket<unknown>,
+    roomId: string,
+    roomCtx: SignalContext<WebSocketExecutionContext>,
+    websocket: WebsocketAdaptor,
+    live?: LiveRegistry,
+  ) {
+    const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws);
+    if (!roomCtxMap || roomCtxMap.get(roomId) !== roomCtx) return false;
+    roomCtxMap.delete(roomId);
+    if (roomCtxMap.size === 0) SignalResolver.#liveWsPubsubRoomCtx.delete(ws);
+    ws.unsubscribe(roomId);
+    SignalResolver.#leaveRoom(roomId, live);
+    websocket.leaveRoom(ws, roomId);
+    return true;
+  }
 
   static async handleWsOpen(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry) {
     await SignalResolver.#getWebsocket(registry).registerSocket(ws);
@@ -870,11 +879,12 @@ export class SignalResolver {
     SignalResolver.#closedWs.add(ws);
     const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws);
     const contexts = [...(roomCtxMap?.values() ?? []), ...(SignalResolver.#liveWsMessageCtx.get(ws) ?? [])];
-    await SignalResolver.#runLifecycleHandlers(contexts, ["unsubscribe", "disconnect"]);
     
-    for (const roomId of roomCtxMap?.keys() ?? []) SignalResolver.#leaveRoom(roomId, live);
     SignalResolver.#liveWsPubsubRoomCtx.delete(ws);
     SignalResolver.#liveWsMessageCtx.delete(ws);
+    await SignalResolver.#runLifecycleHandlers(contexts, ["unsubscribe", "disconnect"]);
+    
+    for (const roomId of roomCtxMap?.keys() ?? []) SignalResolver.#leaveRoom(roomId, live);
 
     await SignalResolver.#getWebsocket(registry).unregisterSocket(ws);
     SignalResolver.logger.verbose(`WebSocket disconnected from all rooms`);

package/server/routeState.ts

@@ -5,6 +5,7 @@ export const AKAN_RSC_STATE_VERSION_HEADER = "X-Akan-Rsc-State-Version";
 export const AKAN_RSC_CURRENT_ROUTE_HEADER = "X-Akan-Rsc-Current-Route";
 export const AKAN_RSC_CURRENT_STATE_HEADER = "X-Akan-Rsc-Current-State";
 export const AKAN_RSC_RESPONSE_STATE_HEADER = "X-Akan-Rsc-State";
+export const AKAN_RSC_NOT_FOUND_HEADER = "X-Akan-Rsc-Not-Found";
 export const AKAN_RSC_PATCH_START_INDEX_HEADER = "X-Akan-Rsc-Patch-Start-Index";
 export const AKAN_RSC_PATCH_SEGMENT_PATH_HEADER = "X-Akan-Rsc-Patch-Segment-Path";
 export const AKAN_RSC_PATCH_START_SEGMENT_HEADER = "X-Akan-Rsc-Patch-Start-Segment";