akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/server/rscWorkerCache.ts

@@ -1,3 +1,4 @@
+import type { PageConfig } from "akanjs/client";
 import {
   hasRouteCacheInvalidationScope,
   type LruTtlCache,
@@ -6,7 +7,15 @@ import {
   type RouteCacheRenderState,
   shouldInvalidateRouteCacheEntry,
 } from "./cachePolicy";
-import type { AkanRouterStateV1, AkanRscPatchDecision, AkanRscPatchMetadata } from "./routeState";
+import {
+  type AkanHeadSnapshotV1,
+  type AkanRouterStateV1,
+  type AkanRscPatchDecision,
+  type AkanRscPatchMetadata,
+  encodeAkanHeadSnapshot,
+  isAkanHeadSnapshotV1,
+} from "./routeState";
+import type { RscTraceMetadata } from "./ssrTypes";
 
 export interface CachedRscResult {
   chunks: Uint8Array[];
@@ -33,8 +42,8 @@ export interface RscPatchCacheKeyInput {
   patch: AkanRscPatchMetadata;
 }
 
-export function createRscPatchCacheKey({ baseEntry, targetRouterState, patch }: RscPatchCacheKeyInput): string {
-  return [
+export function createRscPatchCacheEntry({ baseEntry, targetRouterState, patch }: RscPatchCacheKeyInput) {
+  const key = [
     "patch-v1",
     baseEntry.key,
     targetRouterState.buildId ?? "",
@@ -46,10 +55,7 @@ export function createRscPatchCacheKey({ baseEntry, targetRouterState, patch }:
     JSON.stringify(patch.segmentPath),
     patch.headSafe === true ? "head-safe" : "head-unsafe",
   ].join("\n");
-}
-
-export function createRscPatchCacheEntry(input: RscPatchCacheKeyInput): RouteCacheEntry {
-  return { key: createRscPatchCacheKey(input), ttl: input.baseEntry.ttl };
+  return { key, ttl: baseEntry.ttl };
 }
 
 export function isRscPatchResultCacheEligible(input: {
@@ -117,7 +123,6 @@ export function resolveRscWorkerPatchCacheEntry(input: {
   if (
     !input.cacheEntry ||
     !input.targetRouterState ||
-    input.safePatchDecision.status !== "patch" ||
     !patch ||
     !isRscPatchResultCacheEligible({ partialCommitEnabled: input.partialCommitEnabled, patch })
   ) {
@@ -180,3 +185,64 @@ export function invalidateCachedRscResults(
     ),
   );
 }
+
+export type CachedRscReplayMessage =
+  | { type: "meta"; requestId: string; theme?: string; status?: number; trace?: RscTraceMetadata }
+  | { type: "cache-state"; requestId: string; state: RouteCacheRenderState }
+  | { type: "chunk"; requestId: string; data: Uint8Array }
+  | { type: "end"; requestId: string };
+
+function yieldToHostEventLoop(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+export async function replayCachedRscResult(input: {
+  requestId: string;
+  chunks: readonly Uint8Array[];
+  theme?: string;
+  trace?: RscTraceMetadata;
+  cacheState?: RouteCacheRenderState;
+  send: (message: CachedRscReplayMessage) => void;
+  isCancelled: () => boolean;
+  yieldToHost?: () => Promise<void>;
+}): Promise<boolean> {
+  const yieldToHost = input.yieldToHost ?? yieldToHostEventLoop;
+  if (input.isCancelled()) return false;
+  const metaMessage: CachedRscReplayMessage = { type: "meta", requestId: input.requestId, theme: input.theme };
+  if (input.trace) metaMessage.trace = input.trace;
+  input.send(metaMessage);
+  input.send({ type: "cache-state", requestId: input.requestId, state: input.cacheState ?? { cacheable: true } });
+  for (let index = 0; index < input.chunks.length; index += 1) {
+    if (input.isCancelled()) return false;
+    input.send({ type: "chunk", requestId: input.requestId, data: input.chunks[index] });
+    await yieldToHost();
+  }
+  if (input.isCancelled()) return false;
+  input.send({ type: "end", requestId: input.requestId });
+  return true;
+}
+
+export function resolveAkanRscHeadSafePatchDecision({
+  partialCommitEnabled,
+  patchDecision,
+  pageConfig,
+  headSnapshot,
+}: {
+  partialCommitEnabled: boolean;
+  patchDecision: AkanRscPatchDecision;
+  pageConfig?: PageConfig;
+  headSnapshot?: AkanHeadSnapshotV1;
+}): AkanRscPatchDecision {
+  if (!partialCommitEnabled || patchDecision.status !== "patch" || !patchDecision.patch) return patchDecision;
+  if (pageConfig?.rscPatchHeadSafe !== true) return fullDecision("head-unsafe", patchDecision);
+  if (!headSnapshot) return fullDecision("head-missing", patchDecision);
+  if (!isAkanHeadSnapshotV1(headSnapshot)) return fullDecision("head-invalid", patchDecision);
+  if (!encodeAkanHeadSnapshot(headSnapshot)) return fullDecision("head-too-large", patchDecision);
+  return { ...patchDecision, patch: { ...patchDecision.patch, headSafe: true, headSnapshot } };
+}
+
+const fullDecision = (reason: string, { commonPrefixLength }: AkanRscPatchDecision): AkanRscPatchDecision => ({
+  status: "full",
+  reason,
+  commonPrefixLength,
+});

package/server/rscWorkerHost.ts

@@ -96,18 +96,6 @@ export function createRscWorkerInvalidateCacheMessage(
   };
 }
 
-/**
- * The RSC worker samples its own process with the same `ProcessMetricsCollector.collect` its host
- * replica uses, so its report carries `pid` / `rssBytes` / `role` / … under the identical names.
- * `AkanServer` spreads the host's report into its own `collect({ role, ...webRouter.getMetrics() })`
- * and `collect` spreads `extra` last (`processMetricsCollector.ts:122`) — so passing these through
- * unprefixed silently overwrote the replica's own process fields, and the replica's RSS was reported
- * nowhere. Rename them onto `rscWorker*`; the `rsc*` render counters, which only the worker
- * produces, pass through untouched.
- *
- * XXX A new process-level field in `ProcessMetricsCollector.collect` must be added here too, or it
- * starts shadowing the replica again.
- */
 export function projectRscWorkerProcessMetrics(metrics: AkanMetricsReport): AkanMetricsReport {
   const {
     role: _role,
@@ -234,8 +222,7 @@ export function createRscHostRenderStream(input: {
             settleStream();
             pendingChunks = nextRscHostPendingChunkCount(pendingChunks, controller.desiredSize);
             if (isRscHostPendingChunkOverflow(pendingChunks, maxPendingChunks)) {
-              const msg = `rsc worker host queue exceeded ${maxPendingChunks} pending chunks`;
-              const error = new Error(msg);
+              const error = new Error(`rsc worker host queue exceeded ${maxPendingChunks} pending chunks`);
               input.onPendingChunkOverflow?.();
               cancelRender(error);
               controller.error(error);
@@ -273,12 +260,9 @@ export function createRscHostRenderStream(input: {
             }
             controller.error(new Error(`redirect after stream started: ${location}`));
           },
-          onLateRedirect: (location, method, status) => {
-            settleLateControl({ type: "redirect", location, method, status });
-          },
-          onCacheState: (state) => {
-            settleCacheState(state);
-          },
+          onLateRedirect: (location, method, status) =>
+            settleLateControl({ type: "redirect", location, method, status }),
+          onCacheState: settleCacheState,
           onNotFound: () => {
             settleLateControl(null);
             settleCacheState({ cacheable: false, reason: "not-found" });
@@ -302,9 +286,7 @@ export function createRscHostRenderStream(input: {
         }
         input.sendRenderOrQueue();
       },
-      cancel: (reason) => {
-        cancelRender(reason);
-      },
+      cancel: cancelRender,
       pull: () => {
         pendingChunks = Math.max(0, pendingChunks - 1);
       },
@@ -339,46 +321,11 @@ export interface RscWorkerReloadInput {
   clientManifest: ClientManifest;
   cssAssets?: Record<string, CssAsset>;
   buildId: number;
-  /**
-   * When the builder emits a freshly bundled `pages-*.js` the host forwards
-   * the new absolute path here so the worker re-imports the new bundle.
-   * Undefined means "keep using the current bundle" (e.g. client-manifest-only
-   * reload after a lazy route build).
-   */
+  /** Undefined keeps the current bundle (e.g. a client-manifest-only reload after a lazy route build). */
   pagesBundlePath?: string;
 }
 
-export interface RscWorkerRestartOptions {
-  /** Initial delay before the first restart attempt. Default: 200ms. */
-  baseDelayMs?: number;
-  /** Upper bound for the exponential backoff. Default: 30s. */
-  maxDelayMs?: number;
-  /**
-   * Give up after this many consecutive failed restarts. `undefined` (default)
-   * means retry forever so a short-lived supervisor outage doesn't wedge the
-   * SSR path permanently.
-   */
-  maxAttempts?: number;
-}
-
-export interface RscWorkerOptions {
-  clientManifest: ClientManifest;
-  /**
-   * Absolute path to the pre-built server pages bundle. Produced by
-   * `akanjs/devkit`'s `PagesBundleBuilder`; the RSC worker imports it with
-   * `await import(bundlePath?v=<buildId>)` — no runtime transforms.
-   */
-  pagesBundlePath: string;
-  /** Initial build id for the pages bundle (see `pagesBundlePath`). */
-  pagesBundleBuildId: number;
-  cssAssets?: Record<string, CssAsset>;
-  i18n?: AkanI18nConfig;
-  /** Exponential-backoff settings for automatic crash recovery. */
-  restart?: RscWorkerRestartOptions;
-}
-
 type WorkerStatus = "starting" | "ready" | "restarting" | "stopped";
-/** Piped only in an ndjson deployment, where an inherited stdout would put text lines into the JSON stream. */
 type RscProcess = Bun.Subprocess;
 
 export class RscWorker {
@@ -403,7 +350,6 @@ export class RscWorker {
 
   #status: WorkerStatus = "starting";
   #killed = false;
-
   #queuedSends: Array<() => void> = [];
   #restartAttempts = 0;
   #restartCount = 0;
@@ -412,25 +358,23 @@ export class RscWorker {
   #lastRecycleAtMono: number | null = null;
   #lastRecycleReason: string | undefined;
   #lastWorkerMetrics: AkanMetricsReport = {};
-  /** Set by the replica: where the worker's forwarded log records go (its hub, or up to the gateway). */
   onLogRecords: ((records: LogRecord[], dropped: number) => void) | null = null;
   #logLevel: number | null = null;
   #hostPendingChunkOverflowCount = 0;
   #restartTimer: ReturnType<typeof setTimeout> | null = null;
   #recycleTimer: ReturnType<typeof setTimeout> | null = null;
   #rollingRecycle: { oldProc: RscProcess; reason: string } | null = null;
-  readonly #restartOpts: Required<Pick<RscWorkerRestartOptions, "baseDelayMs" | "maxDelayMs">> & {
-    maxAttempts: number | undefined;
-  };
 
-  constructor(artifact: BaseBuildArtifact) {
+  readonly #failBeforeReady: boolean;
+
+  constructor(artifact: BaseBuildArtifact, { failBeforeReady = false }: { failBeforeReady?: boolean } = {}) {
+    this.#failBeforeReady = failBeforeReady;
     this.#clientManifest = artifact.rscRuntimeClientManifest ?? {};
     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) => {
       this.#resolveReady = () => {
         if (this.#readyResolved) return;
@@ -447,64 +391,16 @@ export class RscWorker {
     this.#proc = this.#spawn();
   }
 
-  render(req: Request): ReadableStream<Uint8Array> {
-    const requestId = crypto.randomUUID();
-
-    const headers: Array<[string, string]> = [];
-    req.headers.forEach((value, key) => {
-      headers.push([key, value]);
-    });
-
-    return new ReadableStream<Uint8Array>({
-      start: (controller) => {
-        this.#pending.set(requestId, {
-          onChunk: (data) => controller.enqueue(data),
-          onEnd: () => controller.close(),
-          onError: (msg) => controller.error(new Error(msg)),
-        });
-        const send = () => {
-
-          if (!this.#pending.has(requestId)) return;
-          try {
-            this.#proc.send({ type: "render", requestId, url: req.url, method: req.method, headers });
-          } catch (err) {
-            this.#resolvePending(requestId, (p) =>
-              p.onError(`rsc worker send failed: ${err instanceof Error ? err.message : String(err)}`),
-            );
-          }
-        };
-        if (this.#status === "ready") send();
-        else if (this.#status === "stopped") {
-          this.#resolvePending(requestId, (p) => p.onError("rsc worker is stopped"));
-        } else {
-          this.#queuedSends.push(send);
-        }
-      },
-      cancel: () => {
-        this.#pending.delete(requestId);
-        this.#cancelRender(requestId);
-      },
-    });
-  }
-
   renderWithMeta(
     req: Request,
     options: { clientManifest?: ClientManifest; signal?: AbortSignal } = {},
   ): Promise<RscRenderResult> {
     const requestId = crypto.randomUUID();
     return createRscHostRenderStream({
-      setPending: (pending) => {
-        this.#pending.set(requestId, pending);
-      },
-      deletePending: () => {
-        this.#pending.delete(requestId);
-      },
-      sendRenderOrQueue: () => {
-        this.#sendRenderOrQueue(requestId, req, options.clientManifest);
-      },
-      cancelRender: () => {
-        this.#cancelRender(requestId);
-      },
+      setPending: (pending) => this.#pending.set(requestId, pending),
+      deletePending: () => this.#pending.delete(requestId),
+      sendRenderOrQueue: () => this.#sendRenderOrQueue(requestId, req, options.clientManifest),
+      cancelRender: () => this.#cancelRender(requestId),
       signal: options.signal,
       onPendingChunkOverflow: () => {
         this.#hostPendingChunkOverflowCount += 1;
@@ -520,7 +416,6 @@ export class RscWorker {
     return this.#call<PagePromptRun>((requestId) => ({ type: "page-prompt.run", requestId, input }));
   }
 
-  /** One request, one reply: the answer is a JSON value rather than a stream, so it rides a promise. */
   #call<T>(message: (requestId: string) => object): Promise<T> {
     const requestId = crypto.randomUUID();
     return new Promise<T>((resolve, reject) => {
@@ -564,14 +459,10 @@ export class RscWorker {
   kill(): void {
     this.#killed = true;
     this.#status = "stopped";
-    if (this.#restartTimer) {
-      clearTimeout(this.#restartTimer);
-      this.#restartTimer = null;
-    }
-    if (this.#recycleTimer) {
-      clearTimeout(this.#recycleTimer);
-      this.#recycleTimer = null;
-    }
+    if (this.#restartTimer) clearTimeout(this.#restartTimer);
+    if (this.#recycleTimer) clearTimeout(this.#recycleTimer);
+    this.#restartTimer = null;
+    this.#recycleTimer = null;
     this.#rollingRecycle?.oldProc.kill();
     this.#rollingRecycle = null;
     this.#proc.kill();
@@ -609,7 +500,7 @@ export class RscWorker {
     }
     if (this.#pending.size > 0 || this.#queuedSends.length > 0) {
       if (!this.#recycleTimer) {
-        const graceMs = RscWorker.#getRscRecycleGraceMs();
+        const graceMs = MemoryLimit.parsePositiveIntEnv("AKAN_RSC_WORKER_RECYCLE_GRACE_MS") ?? 5_000;
         this.#recycleTimer = setTimeout(() => {
           this.#recycleTimer = null;
           this.restartWhenIdle(reason);
@@ -620,20 +511,13 @@ export class RscWorker {
     this.#lastRecycleReason = reason;
     this.#recycleCount += 1;
     this.#lastRecycleAtMono = performance.now();
-    const oldPid = this.#proc.pid;
-    this.#logger.info(`[rsc] rolling recycle worker reason=${reason} oldPid=${oldPid}`);
+    this.#logger.info(`[rsc] rolling recycle worker reason=${reason} oldPid=${this.#proc.pid}`);
     this.#status = "restarting";
-    const oldProc = this.#proc;
-    this.#rollingRecycle = { oldProc, reason };
+    this.#rollingRecycle = { oldProc: this.#proc, reason };
     this.#proc = this.#spawn();
     return true;
   }
 
-  /**
-   * Update just the CSS assets the worker inlines into rendered HTML, without
-   * re-importing any pages. Cheap enough to use for CSS-only HMR cycles so
-   * a subsequent hard refresh serves the latest hashed stylesheet.
-   */
   updateCssAssets(cssAssets: Record<string, CssAsset>): void {
     this.#cssAssets = cssAssets;
     if (this.#status !== "ready") return;
@@ -643,19 +527,12 @@ export class RscWorker {
     }
   }
 
-  /**
-   * Apply a new client manifest + CSS assets and instruct the worker to re-import
-   * the pages bundle with a bumped cache-bust token. When `pagesBundlePath`
-   * is provided the worker switches to the new bundle URL too (the builder
-   * emits a fresh hashed filename on every rebundle). Resolves once the
-   * worker has acknowledged via `reloaded`.
-   */
   reload(input: RscWorkerReloadInput): Promise<void> {
     this.#clientManifest = input.clientManifest;
     this.#cssAssets = input.cssAssets ?? this.#cssAssets;
     this.#pagesBundleBuildId = input.buildId;
     if (input.pagesBundlePath) this.#pagesBundlePath = input.pagesBundlePath;
-
+    
     if (this.#status !== "ready") return Promise.resolve();
 
     if (this.#shouldRecycleForReloadAccumulation() && this.restartWhenIdle("pages-reload-accumulation")) {
@@ -663,7 +540,7 @@ export class RscWorker {
     }
     this.#reloadsSinceSpawn += 1;
     return new Promise<void>((resolve, reject) => {
-
+      
       if (this.#pendingReload) this.#pendingReload.resolve();
       this.#pendingReload = { resolve, reject, targetBuildId: input.buildId };
       try {
@@ -687,6 +564,7 @@ export class RscWorker {
     const workerPath = this.#resolveWorkerPath();
     let proc!: RscProcess;
     const earlyMessages: RscInMsg[] = [];
+    
     const piped = Logger.isNdjson;
     proc = Bun.spawn(["bun", "--conditions", "react-server", workerPath], {
       ipc: (message: RscInMsg) => {
@@ -710,7 +588,6 @@ export class RscWorker {
     return proc;
   }
 
-  /** The worker's own stdout and stderr as records of this replica, so a crash stack reaches the collector as JSON. */
   #readOutput(proc: RscProcess) {
     const replicaIdx = Number(process.env.AKAN_REPLICA_IDX);
     const record = (type: "stdout" | "stderr", text: string) =>
@@ -756,7 +633,7 @@ export class RscWorker {
     }
     switch (message.type) {
       case "hello":
-
+        
         this.#proc.send({
           type: "init",
           clientManifest: this.#clientManifest,
@@ -818,9 +695,11 @@ export class RscWorker {
         return;
       case "error":
         if (message.requestId === "__init__") {
-
           if (!this.#readyResolved) this.#rejectReady(new Error(String(message.message)));
-          else this.#logger.error(`[rsc] worker init error on restart: ${message.message}`);
+          else {
+            this.#logger.error(`[rsc] worker init error on restart: ${message.message}`);
+            proc.kill();
+          }
           return;
         }
         if (message.requestId === "__reload__") {
@@ -901,7 +780,7 @@ export class RscWorker {
   }
 
   #handleExit(proc: RscProcess, code: number | null): void {
-
+    
     if (proc !== this.#proc) return;
 
     const err = new Error(`rsc worker exited with code ${code}`);
@@ -913,31 +792,25 @@ export class RscWorker {
       this.#pendingReload.reject(err);
       this.#pendingReload = null;
     }
-
     this.#queuedSends = [];
 
     if (this.#killed) {
       this.#status = "stopped";
       return;
     }
+    if (this.#failBeforeReady && !this.#readyResolved) {
+      this.#status = "stopped";
+      this.#rejectReady(err);
+      return;
+    }
 
     this.#scheduleRestart();
   }
 
   #scheduleRestart(): void {
-    const attempt = this.#restartAttempts;
-    if (this.#restartOpts.maxAttempts !== undefined && attempt >= this.#restartOpts.maxAttempts) {
-      this.#status = "stopped";
-      const msg = `[rsc] worker failed ${attempt} restarts; giving up. SSR will return errors until the server restarts.`;
-      this.#logger.error(msg);
-      
-      this.#rejectReady(new Error(msg));
-      return;
-    }
-
     this.#status = "restarting";
-    const delay = Math.min(this.#restartOpts.baseDelayMs * 2 ** attempt, this.#restartOpts.maxDelayMs);
-    this.#restartAttempts = attempt + 1;
+    const delay = Math.min(200 * 2 ** this.#restartAttempts, 30_000);
+    this.#restartAttempts += 1;
     this.#restartCount += 1;
     this.#logger.verbose(`[rsc] worker crashed, restarting in ${delay}ms (attempt ${this.#restartAttempts})`);
     this.#restartTimer = setTimeout(() => {
@@ -955,10 +828,10 @@ export class RscWorker {
   #shouldRecycleForReloadAccumulation(): boolean {
     const maxReloads = RscWorker.#getRscMaxReloads();
     if (!maxReloads || this.#reloadsSinceSpawn < maxReloads) return false;
-
-    const sinceLastRecycleMs = this.#lastRecycleAtMono === null ? null : performance.now() - this.#lastRecycleAtMono;
-    if (sinceLastRecycleMs !== null && sinceLastRecycleMs < RscWorker.#getRscMinRecycleIntervalMs()) return false;
-    return true;
+    
+    if (this.#lastRecycleAtMono === null) return true;
+    const minIntervalMs = MemoryLimit.parsePositiveIntEnv("AKAN_RSC_WORKER_MIN_RECYCLE_INTERVAL_MS") ?? 1_000;
+    return performance.now() - this.#lastRecycleAtMono >= minIntervalMs;
   }
 
   #maybeRecycleFromMetrics(metrics: AkanMetricsReport): void {
@@ -973,32 +846,16 @@ export class RscWorker {
       this.restartWhenIdle(`renderCount>${maxRenderCount}`);
       return;
     }
-    const maxRouteModules = RscWorker.#getRscMaxRouteModules();
+    const maxRouteModules = MemoryLimit.parsePositiveIntEnv("AKAN_RSC_WORKER_MAX_ROUTE_MODULES");
     if (maxRouteModules && (metrics.rscLoadedRouteModuleCount ?? 0) >= maxRouteModules) {
       this.restartWhenIdle(`routeModules>${maxRouteModules}`);
     }
   }
 
-  static #isProductionRuntime(): boolean {
-    return process.env.NODE_ENV === "production";
-  }
-
-  static #getRscRecycleGraceMs(): number {
-    return MemoryLimit.parsePositiveIntEnv("AKAN_RSC_WORKER_RECYCLE_GRACE_MS") ?? 5_000;
-  }
-
-  /**
-   * Reloads tolerated before the worker is recycled instead of reloaded in place. Production imports
-   * the pages bundle once at boot and never reloads, so the threshold only applies to dev.
-   */
   static #getRscMaxReloads(): number | null {
     if (process.env.AKAN_RSC_WORKER_MAX_RELOADS !== undefined)
       return MemoryLimit.parsePositiveIntEnv("AKAN_RSC_WORKER_MAX_RELOADS");
-    return RscWorker.#isProductionRuntime() ? null : RscWorker.#devMaxReloads;
-  }
-
-  static #getRscMinRecycleIntervalMs(): number {
-    return MemoryLimit.parsePositiveIntEnv("AKAN_RSC_WORKER_MIN_RECYCLE_INTERVAL_MS") ?? 1_000;
+    return process.env.NODE_ENV === "production" ? null : RscWorker.#devMaxReloads;
   }
 
   static #getRscMaxRssBytes(): number | null {
@@ -1006,12 +863,8 @@ export class RscWorker {
       megabytesEnv: "AKAN_RSC_WORKER_MAX_RSS_MB",
       bytesEnv: "AKAN_RSC_WORKER_MAX_RSS",
       limitFraction: 0.55,
-
-      fallbackBytes: RscWorker.#isProductionRuntime() ? null : RscWorker.#devMaxRssBytes,
+      
+      fallbackBytes: process.env.NODE_ENV === "production" ? null : RscWorker.#devMaxRssBytes,
     });
   }
-
-  static #getRscMaxRouteModules(): number | null {
-    return MemoryLimit.parsePositiveIntEnv("AKAN_RSC_WORKER_MAX_ROUTE_MODULES");
-  }
 }

package/server/semaphore.ts

@@ -13,7 +13,7 @@ export class Semaphore {
     try {
       return await task();
     } finally {
-
+      
       const next = this.#waiters.shift();
       if (next) next();
       else this.#running -= 1;

package/server/sitemap.ts

@@ -31,9 +31,7 @@ export function createDefaultSitemapUrls({ origin, basePath, entries, i18n }: De
 }
 
 export function isSitemapPath(pathname: string, basePaths: readonly string[]): boolean {
-  const normalized = normalizePathname(pathname);
-  if (basePaths.length === 0) return normalized === "/sitemap.xml";
-  return normalized === "/sitemap.xml";
+  return normalizePathname(pathname) === "/sitemap.xml";
 }
 
 export function getSitemapBasePath(