akanjs 2.2.10 → 2.2.12

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # akanjs
 
+## 2.2.12
+
+### Patch Changes
+
+- 666e46c: Improve SSR hydration payload handling, redirect status propagation, and restore dev HMR incremental refresh behavior.
+- 666e46c: Align RSC not-found responses with HTTP 404 semantics and add request-scoped policy tracking for future cache decisions.
+
+## 2.2.11
+
+### Patch Changes
+
+- 8190632: Add Akan server console support with CLI/build integration and documentation for console-oriented workflows.
+- 4bce7f9: Add initial LLM discovery docs and stabilize Akan client/runtime behavior.
+
+  - Add `/llms.txt` documentation discovery for Akan docs.
+  - Add `wsConnect` support for automatic WebSocket connections.
+  - Delay client bootstrap module execution until the SSR fizz stream is ready.
+  - Improve route tree, HMR, fetch, store, and SSR/client runtime stability.
+
 ## 2.2.7
 
 ### Patch Changes

package/client/cookie.ts

@@ -1,7 +1,7 @@
 import { getEnv } from "akanjs/base";
 import { decodeJwtPayload, Logger } from "akanjs/common";
 import type { Account } from "akanjs/fetch";
-import { requestStorage } from "akanjs/fetch";
+import { cookies as serverCookies, headers as serverHeaders } from "akanjs/fetch";
 import { loadCapacitorCore } from "./capacitor";
 import { storage } from "./storage";
 import { fetch } from "./useClient";
@@ -30,11 +30,7 @@ function parseCookieHeader(cookieHeader: string): Map<string, { name: string; va
 }
 
 export const cookies = (): Map<string, { name: string; value: string }> => {
-  if (getEnv().side === "server") {
-    const req = requestStorage?.getStore();
-    if (!req) return new Map();
-    return parseCookieHeader(req.headers.get("cookie") ?? "");
-  }
+  if (getEnv().side === "server") return serverCookies();
   return parseCookieHeader(document.cookie);
 };
 
@@ -75,13 +71,7 @@ export const removeCookie = (key: string, options: { path: string } = { path: "/
 };
 export const headers = (): Map<string, string> => {
   if (getEnv().side !== "server") return new Map();
-  const req = requestStorage?.getStore();
-  if (!req) return new Map();
-  const map = new Map<string, string>();
-  req.headers.forEach((value, key) => {
-    map.set(key, value);
-  });
-  return map;
+  return serverHeaders();
 };
 
 export const getHeader = (key: string): string | undefined => {

package/client/router.ts

@@ -35,12 +35,18 @@ interface CSRClientRouterOption extends RouterOptions {
   router: RouterInstance;
 }
 export type RedirectMethod = "replace" | "push";
+export type RedirectStatus = 303 | 307 | 308;
+export interface RedirectOptions {
+  method?: RedirectMethod;
+  status?: RedirectStatus;
+}
 
 export class AkanRedirectError extends Error {
   readonly digest = "AKAN_REDIRECT";
   constructor(
     readonly location: string,
     readonly method: RedirectMethod = "replace",
+    readonly status: RedirectStatus = 307,
   ) {
     super(`Redirect to ${location}`);
     this.name = "AkanRedirectError";
@@ -246,7 +252,9 @@ class Router {
     this.#instance.refresh();
     return undefined as never;
   }
-  redirect(href: string): never {
+  redirect(href: string, options: RedirectOptions = {}): never {
+    const method = options.method ?? "replace";
+    const status = options.status ?? 307;
     if (getEnv().side === "server") {
       const { getRequest, headers: requestHeaders } = getServerRequestContext();
       const h = requestHeaders();
@@ -257,9 +265,9 @@ class Router {
       const basePath = getServerBasePath(reqPathname, lang, h.get("x-base-path") ?? undefined, this.#prefix);
       const { pathname, href: fullHref } = getPathInfo(href, lang, shouldExposeBasePath() ? basePath : "");
       Logger.log(`redirect to:${pathname}`);
-      throw new AkanRedirectError(fullHref, "replace");
+      throw new AkanRedirectError(fullHref, method, status);
     } else {
-      this.#instance.replace(href);
+      this.#instance[method](href);
     }
     return undefined as never;
   }

package/fetch/requestStorage.ts

@@ -1,15 +1,35 @@
-export interface RequestStorage {
-  run<T>(store: Request, callback: () => T): T;
-  getStore(): Request | undefined;
+export type AkanTheme = "css" | "system" | (string & {});
+
+export interface AkanRequestPolicy {
+  routeId?: string;
+  rscCache?: "public" | false;
+  rscCacheTtl?: number;
+  cacheable?: boolean;
+  revalidate?: number | false;
+  tags: Set<string>;
 }
 
-export type AkanTheme = "css" | "system" | (string & {});
+export interface AkanDynamicUsage {
+  headers: boolean;
+  cookies: boolean;
+}
+
+export interface AkanRequestStore {
+  request: Request;
+  theme?: AkanTheme;
+  queryCache: Map<string, Promise<unknown>>;
+  policy: AkanRequestPolicy;
+  dynamicUsage: AkanDynamicUsage;
+}
+
+export interface RequestStorage {
+  run<T>(store: Request | AkanRequestStore, callback: () => T): T;
+  getStore(): AkanRequestStore | undefined;
+}
 
 declare global {
   var __AKAN_REQUEST_STORAGE__: RequestStorage | undefined;
-  var __AKAN_REQUEST_THEME__: WeakMap<Request, AkanTheme> | undefined;
-  var __AKAN_REQUEST_QUERY_CACHE__: WeakMap<Request, Map<string, Promise<unknown>>> | undefined;
-  var __AKAN_REQUEST_FALLBACK_STACK__: Request[] | undefined;
+  var __AKAN_REQUEST_FALLBACK_STACK__: AkanRequestStore[] | undefined;
 }
 
 let _requestStorage: RequestStorage | null = null;
@@ -17,74 +37,120 @@ if (typeof window === "undefined") {
   try {
 
     const { AsyncLocalStorage } = require("node:async_hooks") as typeof import("node:async_hooks");
-    globalThis.__AKAN_REQUEST_STORAGE__ ??= new AsyncLocalStorage() as RequestStorage;
+    const als = new AsyncLocalStorage<AkanRequestStore>();
+    globalThis.__AKAN_REQUEST_STORAGE__ ??= {
+      run<T>(store: Request | AkanRequestStore, callback: () => T): T {
+        return als.run(normalizeRequestStore(store), callback);
+      },
+      getStore(): AkanRequestStore | undefined {
+        return als.getStore();
+      },
+    };
     _requestStorage = globalThis.__AKAN_REQUEST_STORAGE__;
   } catch {}
 }
 
 export const requestStorage: RequestStorage | null = _requestStorage;
 
-function requestThemeMap(): WeakMap<Request, AkanTheme> {
-  globalThis.__AKAN_REQUEST_THEME__ ??= new WeakMap<Request, AkanTheme>();
-  return globalThis.__AKAN_REQUEST_THEME__;
+function createRequestPolicy(): AkanRequestPolicy {
+  return { tags: new Set() };
+}
+
+export function createRequestStore(
+  request: Request,
+  policy: Partial<Omit<AkanRequestPolicy, "tags">> = {},
+): AkanRequestStore {
+  return {
+    request,
+    queryCache: new Map(),
+    policy: { ...createRequestPolicy(), ...policy },
+    dynamicUsage: { headers: false, cookies: false },
+  };
+}
+
+function isRequestStore(store: Request | AkanRequestStore | undefined): store is AkanRequestStore {
+  return Boolean(store && typeof store === "object" && "request" in store && store.request instanceof Request);
+}
+
+function normalizeRequestStore(store: Request | AkanRequestStore): AkanRequestStore {
+  return isRequestStore(store) ? store : createRequestStore(store);
 }
 
-function requestQueryCacheMap(): WeakMap<Request, Map<string, Promise<unknown>>> {
-  globalThis.__AKAN_REQUEST_QUERY_CACHE__ ??= new WeakMap<Request, Map<string, Promise<unknown>>>();
-  return globalThis.__AKAN_REQUEST_QUERY_CACHE__;
+function getActiveRequestStore(): AkanRequestStore | undefined {
+  const store = requestStorage?.getStore() as Request | AkanRequestStore | undefined;
+  if (store) return isRequestStore(store) ? store : createRequestStore(store);
+  return globalThis.__AKAN_REQUEST_FALLBACK_STACK__?.at(-1);
 }
 
 /** Stores theme preference on the active request when server rendering. */
 export function setRequestTheme(theme: AkanTheme | undefined): void {
-  const req = getRequest();
-  if (!req || theme === undefined) return;
-  requestThemeMap().set(req, theme);
+  const store = getRequestStore();
+  if (!store || theme === undefined) return;
+  store.theme = theme;
 }
 
 export function getRequestTheme(): AkanTheme | undefined {
-  const req = getRequest();
-  if (!req) return undefined;
-  return requestThemeMap().get(req);
+  return getRequestStore()?.theme;
 }
 
 export function pushRequestFallback(req: Request): () => void {
   globalThis.__AKAN_REQUEST_FALLBACK_STACK__ ??= [];
   const stack = globalThis.__AKAN_REQUEST_FALLBACK_STACK__;
-  stack.push(req);
+  const store = createRequestStore(req);
+  stack.push(store);
   return () => {
-    const index = stack.lastIndexOf(req);
+    const index = stack.lastIndexOf(store);
     if (index >= 0) stack.splice(index, 1);
   };
 }
 
+/** Returns the active server request store from AsyncLocalStorage or the fallback stack. */
+export function getRequestStore(): AkanRequestStore | undefined {
+  return getActiveRequestStore();
+}
+
 /** Returns the active server request from AsyncLocalStorage or the fallback stack. */
 export function getRequest(): Request | undefined {
-  return requestStorage?.getStore() ?? globalThis.__AKAN_REQUEST_FALLBACK_STACK__?.at(-1);
+  return getRequestStore()?.request;
+}
+
+export function getRequestPolicy(): AkanRequestPolicy | undefined {
+  return getRequestStore()?.policy;
+}
+
+export function updateRequestPolicy(
+  patch: Partial<Omit<AkanRequestPolicy, "tags">> & { tags?: Iterable<string> },
+): AkanRequestPolicy | undefined {
+  const policy = getRequestPolicy();
+  if (!policy) return undefined;
+  const { tags, ...rest } = patch;
+  Object.assign(policy, rest);
+  if (tags) for (const tag of tags) policy.tags.add(tag);
+  return policy;
+}
+
+export function getRequestDynamicUsage(): AkanDynamicUsage | undefined {
+  return getRequestStore()?.dynamicUsage;
 }
 
 /** Deduplicates a promise-producing query within the active request. */
 export function memoizeRequestQuery<T>(key: string, factory: () => Promise<T>): Promise<T> {
-  const req = getRequest();
-  if (!req) return factory();
-  const cacheMap = requestQueryCacheMap();
-  let cache = cacheMap.get(req);
-  if (!cache) {
-    cache = new Map<string, Promise<unknown>>();
-    cacheMap.set(req, cache);
-  }
-  const existing = cache.get(key);
+  const store = getRequestStore();
+  if (!store) return factory();
+  const existing = store.queryCache.get(key);
   if (existing) return existing as Promise<T>;
   const promise = factory();
-  cache.set(key, promise);
+  store.queryCache.set(key, promise);
   return promise;
 }
 
 /** Returns current request headers as a Map, or an empty Map outside a request. */
 export function headers(): Map<string, string> {
-  const req = getRequest();
+  const store = getRequestStore();
   const map = new Map<string, string>();
-  if (!req) return map;
-  req.headers.forEach((value, key) => {
+  if (!store) return map;
+  store.dynamicUsage.headers = true;
+  store.request.headers.forEach((value, key) => {
     map.set(key, value);
   });
   return map;
@@ -121,7 +187,8 @@ export function parseCookieHeader(cookieHeader: string): Map<string, CookieEntry
 
 /** Returns parsed cookies from the current request, or an empty Map outside a request. */
 export function cookies(): Map<string, CookieEntry> {
-  const req = getRequest();
-  if (!req) return new Map();
-  return parseCookieHeader(req.headers.get("cookie") ?? "");
+  const store = getRequestStore();
+  if (!store) return new Map();
+  store.dynamicUsage.cookies = true;
+  return parseCookieHeader(store.request.headers.get("cookie") ?? "");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.2.10",
+  "version": "2.2.12",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/akanServer.ts

@@ -39,6 +39,19 @@ interface AkanAppPrepared {
   webProxyRunner: WebProxyRunner | null;
 }
 
+export interface AkanServerConsoleInfo {
+  name: string;
+  status: AkanServer["status"];
+  serverMode: AkanServer["serverMode"];
+  env: Pick<BaseEnv, "appName" | "environment" | "operationMode" | "repoName" | "serveDomain" | "databaseMode">;
+  services: string[];
+  signals: string[];
+  adaptors: string[];
+  uses: string[];
+  serviceStages: string[][];
+  adaptorStages: string[][];
+}
+
 export class AkanServer {
   status: "stopped" | "initializing" | "initialized" | "starting" | "running" | "stopping" = "stopped";
 
@@ -120,6 +133,29 @@ export class AkanServer {
     return this.#di.getAdaptor<T>(refName);
   }
 
+  inspectConsole(): AkanServerConsoleInfo {
+    this.#assertCanGet();
+    return {
+      name: this.name,
+      status: this.status,
+      serverMode: this.serverMode,
+      env: {
+        appName: this.env.appName,
+        environment: this.env.environment,
+        operationMode: this.env.operationMode,
+        repoName: this.env.repoName,
+        serveDomain: this.env.serveDomain,
+        databaseMode: this.env.databaseMode,
+      },
+      services: [...this.#di.registry.serviceCls.keys()].sort((a, b) => a.localeCompare(b)),
+      signals: [...this.#di.registry.serverSignalCls.keys()].sort((a, b) => a.localeCompare(b)),
+      adaptors: [...this.#di.registry.adaptorCls.keys()].sort((a, b) => a.localeCompare(b)),
+      uses: [...this.#di.registry.uses.keys()].sort((a, b) => a.localeCompare(b)),
+      serviceStages: this.#di.hierarchy.serviceStages.map((stage) => [...stage]),
+      adaptorStages: this.#di.hierarchy.adaptorStages.map((stage) => [...stage]),
+    };
+  }
+
   async init({ routes: initRoutes = true, web = true }: { routes?: boolean; web?: boolean } = {}) {
     if (this.status !== "stopped") throw new Error("AkanServer is not able to init. It is already running.");
     this.status = "initializing";
@@ -248,14 +284,14 @@ export class AkanServer {
   }
 
   async start({ listen, web = true }: { listen?: boolean; web?: boolean } = {}) {
-    const isScriptCommand = process.env.AKAN_COMMAND_TYPE === "script";
-    const shouldListen = (listen ?? !isScriptCommand) && this.serverMode !== "batch";
+    const isNoListenCommand = process.env.AKAN_COMMAND_TYPE === "script" || process.env.AKAN_COMMAND_TYPE === "console";
+    const shouldListen = (listen ?? !isNoListenCommand) && this.serverMode !== "batch";
     await this.init({ routes: shouldListen, web });
     if (!shouldListen) {
       const websocket = this.#di.getWebsocketAdaptor();
       if (websocket) SignalResolver.setLocalPublish((roomId, data) => this.#localPublish?.(roomId, data), websocket);
       this.status = "running";
-      if (!isScriptCommand) {
+      if (!isNoListenCommand) {
         this.#startMetricsReporting();
         this.#di.registerSchedule(this.serverMode);
         process.on("message", (message) => this.#handleIpcMessage(message as AkanIpcMessage));

package/server/console.ts

@@ -0,0 +1,189 @@
+import { createInterface } from "node:readline/promises";
+import { inspect } from "node:util";
+import type { BaseEnv } from "akanjs/base";
+import type { Adaptor, Service } from "akanjs/service";
+import type { ServerSignal } from "akanjs/signal";
+import type { AkanServer } from "./akanServer";
+
+type AsyncFunctionConstructor = new (...args: string[]) => (scope: object) => Promise<unknown>;
+
+const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor as AsyncFunctionConstructor;
+
+export interface AkanConsoleOptions {
+  prompt?: string;
+  globals?: Record<string, unknown>;
+  input?: typeof process.stdin;
+  output?: typeof process.stdout;
+}
+
+export interface AkanConsoleContext extends Record<string, unknown> {
+  server: AkanServer;
+  env: AkanServer["env"];
+  get: AkanServer["get"];
+  service: <T = Service>(refName: string) => T;
+  signal: <T = ServerSignal>(refName: string) => T;
+  adaptor: <T = Adaptor>(refName: string) => T;
+  methods: (value: unknown) => string[];
+  debug: () => ReturnType<AkanServer["inspectConsole"]>;
+}
+
+export const assertAkanConsoleAllowed = (
+  env: Pick<BaseEnv, "environment" | "operationMode"> = {
+    environment: (process.env.AKAN_PUBLIC_ENV ?? "debug") as BaseEnv["environment"],
+    operationMode: (process.env.AKAN_PUBLIC_OPERATION_MODE ?? "cloud") as BaseEnv["operationMode"],
+  },
+) => {
+  const isProductionLike =
+    env.environment === "main" ||
+    env.operationMode === "cloud" ||
+    env.operationMode === "edge" ||
+    process.env.NODE_ENV === "production";
+  if (!isProductionLike || process.env.AKAN_CONSOLE === "1") return;
+
+  throw new Error(
+    [
+      "Akan console is disabled for production-like environments.",
+      "Run with AKAN_CONSOLE=1 only for the exec command that opens the console.",
+      "Example: AKAN_CONSOLE=1 bun console.js",
+    ].join("\n"),
+  );
+};
+
+export const getAkanConsoleMethods = (value: unknown): string[] => {
+  const names = new Set<string>();
+  let proto =
+    typeof value === "function"
+      ? value.prototype
+      : value && (typeof value === "object" || typeof value === "function")
+        ? Object.getPrototypeOf(value)
+        : null;
+
+  while (proto && proto !== Object.prototype) {
+    for (const name of Object.getOwnPropertyNames(proto)) {
+      if (name === "constructor") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+      if (typeof descriptor?.value === "function") names.add(name);
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return [...names].sort((a, b) => a.localeCompare(b));
+};
+
+export const createAkanConsoleContext = (
+  server: AkanServer,
+  globals: Record<string, unknown> = {},
+): AkanConsoleContext => {
+  const context = {
+    server,
+    env: server.env,
+    get: server.get.bind(server) as AkanServer["get"],
+    service: server.getService.bind(server),
+    signal: server.getSignal.bind(server),
+    adaptor: server.getAdaptor.bind(server),
+    methods: getAkanConsoleMethods,
+    debug: () => server.inspectConsole(),
+    ...globals,
+  };
+  return context;
+};
+
+const createScope = (context: Record<string, unknown>) =>
+  new Proxy(context, {
+    has: () => true,
+    get(target, prop) {
+      if (prop === Symbol.unscopables) return undefined;
+      if (prop in target) return target[prop as keyof typeof target];
+      return (globalThis as Record<PropertyKey, unknown>)[prop];
+    },
+    set(target, prop, value) {
+      target[prop as keyof typeof target] = value;
+      return true;
+    },
+  });
+
+export const evaluateAkanConsoleInput = async (source: string, context: Record<string, unknown>) => {
+  const trimmed = source.trim();
+  if (!trimmed) return undefined;
+  const scope = createScope(context);
+
+  try {
+    return await new AsyncFunction("scope", `with (scope) { return await (${trimmed}); }`)(scope);
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    return await new AsyncFunction("scope", `with (scope) { return await (async () => {\n${trimmed}\n})(); }`)(scope);
+  }
+};
+
+const printHelp = (output: typeof process.stdout) => {
+  output.write(
+    [
+      "Akan console commands:",
+      "  .help       Show this help",
+      "  .globals    Show available global names",
+      "  .exit       Close the console",
+      "",
+      "Examples:",
+      "  debug()",
+      '  methods(service("user"))',
+      '  await service("user").__count()',
+      '  userService = service("user")',
+      "",
+    ].join("\n"),
+  );
+};
+
+const formatValue = (value: unknown) => {
+  if (value === undefined) return "";
+  return `${inspect(value, { colors: true, depth: 5, maxArrayLength: 100 })}\n`;
+};
+
+export const startAkanConsole = async (server: AkanServer, options: AkanConsoleOptions = {}) => {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const context = createAkanConsoleContext(server, options.globals);
+  const prompt = options.prompt ?? `akan:${server.name}> `;
+  const rl = createInterface({ input, output, terminal: true });
+
+  output.write(`Akan console started for ${server.name}. Type .help for commands.\n`);
+  rl.setPrompt(prompt);
+  rl.prompt();
+
+  rl.on("SIGINT", () => {
+    output.write("\n");
+    rl.close();
+  });
+
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    try {
+      if (!trimmed) {
+        rl.prompt();
+        continue;
+      }
+      if (trimmed === ".exit" || trimmed === ".quit") {
+        rl.close();
+        break;
+      }
+      if (trimmed === ".help") {
+        printHelp(output);
+        rl.prompt();
+        continue;
+      }
+      if (trimmed === ".globals") {
+        output.write(
+          `${Object.keys(context)
+            .sort((a, b) => a.localeCompare(b))
+            .join(", ")}\n`,
+        );
+        rl.prompt();
+        continue;
+      }
+
+      output.write(formatValue(await evaluateAkanConsoleInput(line, context)));
+    } catch (error) {
+      output.write(`${error instanceof Error ? error.stack || error.message : String(error)}\n`);
+    }
+    rl.prompt();
+  }
+};

package/server/hmr/clientScript.ts

@@ -45,11 +45,11 @@ export const HMR_CLIENT_SCRIPT = `(function(){
         return;
       }
       if (msg.type === "rsc-refresh") {
-        reloadForHmr(msg);
+        refreshRsc(msg);
         return;
       }
       if (msg.type === "client-refresh") {
-        reloadForHmr(msg);
+        refreshClient(msg);
         return;
       }
       if (msg.type === "css-update") {
@@ -73,12 +73,6 @@ export const HMR_CLIENT_SCRIPT = `(function(){
     setTimeout(connect, delay);
   }
 
-  function reloadForHmr(msg){
-    try { self.__AKAN_RSC_CLEAR_CACHE__ && self.__AKAN_RSC_CLEAR_CACHE__(); } catch(e){}
-    if (msg && msg.buildId != null) lastBuildId = msg.buildId;
-    location.reload();
-  }
-
   function ensureOverlay(){
     if (overlayEl && overlayLabelEl) return overlayEl;
     if (!overlayStyleEl) {

package/server/index.ts

@@ -3,6 +3,7 @@ export * from "./akanLib";
 export * from "./akanOption";
 export * from "./akanServer";
 export * from "./artifact";
+export * from "./console";
 export * from "./decorators";
 export type { ChangeBatch, ChangeKind } from "./hmr/changeBatch";
 export * from "./processMetricsCollector";

package/server/rscClient.tsx

@@ -1,11 +1,14 @@
 import { createElement, type ReactNode, startTransition, use, useLayoutEffect, useState } from "react";
 import { hydrateRoot } from "react-dom/client";
 import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
+import { isRscPayloadResponse } from "./rscHttp";
+
+type InlineRscChunk = [1, string] | [3, string];
 
 declare global {
-  var __RSC_CHUNKS__: string[] | undefined;
+  var __RSC_CHUNKS__: InlineRscChunk[] | undefined;
   var __RSC_CLOSED__: boolean | undefined;
-  var __RSC_PUSH__: ((b64: string) => void) | undefined;
+  var __RSC_PUSH__: ((type: InlineRscChunk[0], data: string) => void) | undefined;
   var __RSC_CLOSE__: (() => void) | undefined;
   var __AKAN_RSC_NAVIGATE__:
     | ((href: string, options?: { replace?: boolean; scrollToTop?: boolean }) => Promise<void>)
@@ -21,15 +24,20 @@ function decodeBase64(b64: string): Uint8Array {
   return bytes;
 }
 
+function decodeInlineRscChunk([type, data]: InlineRscChunk): Uint8Array {
+  if (type === 1) return new TextEncoder().encode(data);
+  return decodeBase64(data);
+}
+
 type RscThenable = Promise<ReactNode>;
-type RscFetchResult = { type: "rsc"; thenable: RscThenable } | { type: "redirected" };
+type RscFetchResult = { type: "rsc"; thenable: RscThenable } | { type: "redirected"; status?: number };
 const MAX_RSC_CACHE_ENTRIES = 32;
 
 function createInitialRscStream(): ReadableStream<Uint8Array> {
   return new ReadableStream<Uint8Array>({
     start(controller) {
       const queued = globalThis.__RSC_CHUNKS__ ?? [];
-      for (const b64 of queued) controller.enqueue(decodeBase64(b64));
+      for (const chunk of queued) controller.enqueue(decodeInlineRscChunk(chunk));
       globalThis.__RSC_CHUNKS__ = [];
 
       if (globalThis.__RSC_CLOSED__) {
@@ -37,7 +45,7 @@ function createInitialRscStream(): ReadableStream<Uint8Array> {
         return;
       }
 
-      globalThis.__RSC_PUSH__ = (b64: string) => controller.enqueue(decodeBase64(b64));
+      globalThis.__RSC_PUSH__ = (type, data) => controller.enqueue(decodeInlineRscChunk([type, data]));
       globalThis.__RSC_CLOSE__ = () => controller.close();
     },
   });
@@ -63,10 +71,12 @@ async function fetchRsc(href: string, options: { buildId?: number } = {}): Promi
   const redirect = res.headers.get("X-Akan-Redirect");
   if (redirect) {
     const method = res.headers.get("X-Akan-Redirect-Method");
+    const statusHeader = res.headers.get("X-Akan-Redirect-Status");
+    const status = statusHeader ? Number(statusHeader) : undefined;
     await globalThis.__AKAN_RSC_NAVIGATE__?.(redirect, { replace: method !== "push", scrollToTop: true });
-    return { type: "redirected" };
+    return { type: "redirected", status };
   }
-  if (!res.ok || !res.body) throw new Error(`[rscClient] RSC fetch failed ${res.status} ${res.statusText}`);
+  if (!isRscPayloadResponse(res)) throw new Error(`[rscClient] RSC fetch failed ${res.status} ${res.statusText}`);
 
   const buffer = await res.arrayBuffer();
   const completeStream = new ReadableStream<Uint8Array>({