akanjs 3.0.0-beta.24 → 3.0.0-beta.26

package/server/hmr/devHmrController.ts

@@ -1,18 +1,23 @@
 import fs from "node:fs";
 import path from "node:path";
 import { Logger } from "akanjs/common";
+import { CrossSiteGuard } from "../../signal/CrossSiteGuard";
 import {
   BuilderRpc,
   type ClientManifest,
+  DevBuildRecovery,
   type DevBuildStatus,
+  type HmrTrace,
   RouteClientCache,
   type RouteSeedIndex,
   RouteSeedIndexStore,
 } from "../artifact";
-import type { RscWorker } from "../rscWorkerHost";
+import type { RscReloadFailure, RscWorker } from "../rscWorkerHost";
 import type { RenderState } from "../types";
-import { CSR_DEV_DIRNAME, CSR_DEV_MANIFEST_FILE, type CsrDevManifest } from "./csrDevManifest";
+import { CSR_DEV_DIRNAME, CSR_DEV_MANIFEST_FILE, type CsrDevManifest, SSR_DEV_DIRNAME } from "./csrDevManifest";
+import { DevArtifactPruner } from "./devArtifactPruner";
 import { isAkanRuntimeMetadataFile } from "./runtimeMetadataFile";
+import { type SsrUpdateMessage, SsrUpdateQueue } from "./ssrUpdateQueue";
 import { type ChangeKind, type HmrMessage, type HmrWsData, HmrWsHub } from "./wsHub";
 
 export { isAkanRuntimeMetadataFile };
@@ -47,10 +52,7 @@ export function devBuildStatusToHmrMessage(
       files: status.files.length,
     };
   }
-  if (!previous || previous.ok) return null;
-  const recovered =
-    status.phase === "backend" ? status.generation >= previous.generation : status.generation > previous.generation;
-  if (!recovered) return null;
+  if (!DevBuildRecovery.recovers(previous, status)) return null;
   return {
     type: "build-status",
     status: "ok",
@@ -67,6 +69,8 @@ export interface DevHmrControllerOptions {
   rsc: RscWorker;
   seedIndex: RouteSeedIndex;
   upgradeHmrWs: (req: Request, data: HmrWsData) => boolean;
+  /** The pages bundle the RSC worker booted with: the base build's, however many pages builds came after it. */
+  pagesBundlePath?: string;
 }
 
 export class DevHmrController {
@@ -76,12 +80,15 @@ export class DevHmrController {
   readonly #rsc: RscWorker;
   readonly #seedIndex: RouteSeedIndex;
   readonly #upgradeHmrWs: (req: Request, data: HmrWsData) => boolean;
-  readonly #fastRefreshEnabled = process.env.AKAN_REACT_FAST_REFRESH !== "0";
   readonly #hub = new HmrWsHub();
+  readonly #ssrUpdates = new SsrUpdateQueue((message) => this.#sendSsrUpdate(message));
   readonly #builderRpc: BuilderRpc;
   readonly routeCache: RouteClientCache;
+  #recheckingRoute = false;
+  #recheckAgain: DevBuildStatus | null = null;
   readonly #recentClientEntries = new Set<string>();
-  readonly #recentClientFiles = new Set<string>();
+  /** File to the newest save that invalidated its routes already: that save's pages build must not drop them again. */
+  readonly #earlyInvalidated = new Map<string, number>();
   readonly #clientFileRouteIds = new Map<string, Set<string>>();
   readonly #clientFileEntries = new Map<string, Set<string>>();
   readonly #clientEntryRouteIds = new Map<string, Set<string>>();
@@ -90,31 +97,54 @@ export class DevHmrController {
   readonly #dirtyFiles = new Set<string>();
   readonly #buildStatusByPhase = new Map<DevBuildStatus["phase"], DevBuildStatus>();
   #graphSeeds: string[];
+  #runningBundlePath: string | null;
+  readonly #pruner: DevArtifactPruner;
 
-  constructor({ artifactDir, renderState, rsc, seedIndex, upgradeHmrWs }: DevHmrControllerOptions) {
+  constructor({ artifactDir, renderState, rsc, seedIndex, upgradeHmrWs, pagesBundlePath }: DevHmrControllerOptions) {
     this.#artifactDir = artifactDir;
+    this.#runningBundlePath = pagesBundlePath ? path.resolve(pagesBundlePath) : null;
+    this.#pruner = new DevArtifactPruner(artifactDir);
     this.#renderState = renderState;
     this.#rsc = rsc;
     this.#seedIndex = seedIndex;
     this.#graphSeeds = DevHmrController.#graphSeedsOf(seedIndex);
     this.#upgradeHmrWs = upgradeHmrWs;
-    this.#renderState.csrGeneration ??= DevHmrController.#readCsrGeneration(artifactDir);
+    this.#renderState.csrGeneration ??= DevHmrController.#readManifest(artifactDir, CSR_DEV_DIRNAME)?.generation;
+    const ssrManifest = DevHmrController.#readManifest(artifactDir, SSR_DEV_DIRNAME);
+    this.#renderState.ssrGeneration ??= ssrManifest?.generation;
+    this.#renderState.ssrEpoch ??= ssrManifest?.epoch;
     this.#builderRpc = this.#createBuilderRpc();
     this.routeCache = this.#createRouteCache();
   }
 
-  static #readCsrGeneration(artifactDir: string): number | undefined {
+  static #readManifest(artifactDir: string, dirName: string): Partial<CsrDevManifest> | undefined {
     try {
-      const manifest = JSON.parse(
-        fs.readFileSync(path.join(artifactDir, CSR_DEV_DIRNAME, CSR_DEV_MANIFEST_FILE), "utf8"),
+      return JSON.parse(
+        fs.readFileSync(path.join(artifactDir, dirName, CSR_DEV_MANIFEST_FILE), "utf8"),
       ) as Partial<CsrDevManifest>;
-      return typeof manifest.generation === "number" ? manifest.generation : undefined;
     } catch {
       
       return undefined;
     }
   }
 
+  refreshRegistryState(): void {
+    const csr = DevHmrController.#readManifest(this.#artifactDir, CSR_DEV_DIRNAME);
+    if (typeof csr?.generation === "number") this.#renderState.csrGeneration = csr.generation;
+    const ssr = DevHmrController.#readManifest(this.#artifactDir, SSR_DEV_DIRNAME);
+    if (typeof ssr?.generation === "number" && this.#ssrUpdates.size === 0)
+      this.#renderState.ssrGeneration = ssr.generation;
+    if (typeof ssr?.epoch === "number") this.#renderState.ssrEpoch = ssr.epoch;
+  }
+
+  /** The phases failing now, for a socket that connects after their status went out (a page opened after a failed boot). */
+  buildErrorMessages(): Extract<HmrMessage, { type: "build-status" }>[] {
+    return [...this.#buildStatusByPhase.values()].flatMap((status) => {
+      const message = status.ok ? null : devBuildStatusToHmrMessage(status);
+      return message ? [message] : [];
+    });
+  }
+
   get hub(): HmrWsHub {
     return this.#hub;
   }
@@ -128,68 +158,24 @@ export class DevHmrController {
   }
 
   handleWs(req: Request): Response | undefined {
-    const client = new URL(req.url).searchParams.get("client") === "csr" ? "csr" : "ssr";
-    if (this.#upgradeHmrWs(req, { kind: "akan-hmr", openedAt: Date.now(), client })) return;
-    return new Response("Failed to upgrade HMR WebSocket", { status: 500 });
-  }
 
-  async handleClientRefresh(req: Request): Promise<Response> {
-    const started = Date.now();
     try {
-      if (!this.#fastRefreshEnabled) return new Response("Fast Refresh disabled", { status: 404 });
-      const reqUrl = new URL(req.url);
-      const clientOrigin = DevHmrController.#clientFacingOrigin(req);
-      const target = reqUrl.searchParams.get("url");
-      const targetUrl = target ? new URL(target, clientOrigin) : reqUrl;
-      if (!DevHmrController.#isTrustedRscTarget(clientOrigin, targetUrl))
-        return new Response("Bad Request", { status: 400 });
-      const manifest = await this.ensureRoute(targetUrl);
-      const chunks = DevHmrController.clientChunkUrls(manifest.clientManifest);
-      this.#logger.verbose(
-        `[hmr] client-refresh metadata route=${targetUrl.pathname} chunks=${chunks.length} in ${Date.now() - started}ms`,
-      );
-      return new Response(
-        JSON.stringify({
-          buildId: this.#renderState.buildId,
-          generation: manifest.generation,
-          chunks,
-          routeIds: this.routeIdsForPath(targetUrl.pathname),
-        }),
-        { headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" } },
-      );
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.#logger.error(`[hmr] client-refresh metadata failed: ${message}`);
-      return new Response(message, { status: 500 });
+      CrossSiteGuard.assertOrigin(req, new URL(req.url), "hmr");
+    } catch {
+      return new Response("Forbidden", { status: 403 });
     }
+    const client = new URL(req.url).searchParams.get("client") === "csr" ? "csr" : "ssr";
+    if (this.#upgradeHmrWs(req, { kind: "akan-hmr", openedAt: Date.now(), client })) return;
+    return new Response("Failed to upgrade HMR WebSocket", { status: 500 });
   }
 
-  async ensureRoute(url: URL) {
-    const started = Date.now();
-    const matched =
-      RouteSeedIndexStore.match(url.pathname, this.#seedIndex.entries) ??
-      RouteSeedIndexStore.matchPrefix(url.pathname, this.#seedIndex.entries);
-    if (matched) await this.routeCache.ensure(matched.entry.routeId, matched.entry.seeds);
-    this.#logger.verbose(
-      `[route-cache] ensure pathname=${url.pathname} routeId=${matched?.entry.routeId ?? "(none)"} in ${Date.now() - started}ms`,
-    );
-    return this.routeCache.snapshot();
-  }
-
-  routeIdsForPath(pathname: string): string[] | undefined {
-    const matched = RouteSeedIndexStore.match(pathname, this.#seedIndex.entries);
-    return matched ? [matched.entry.routeId] : undefined;
+  #sendSsrUpdate(message: SsrUpdateMessage): void {
+    this.#renderState.ssrGeneration = message.generation;
+    this.#hub.broadcast({ ...message, trace: DevHmrController.#broadcastTrace(message.trace) });
   }
 
-  static clientChunkUrls(clientManifest: ClientManifest): string[] {
-    const urls = new Set<string>();
-    for (const row of Object.values(clientManifest)) {
-      urls.add(row.id);
-      for (const chunk of row.chunks) {
-        if (chunk.startsWith("/_akan/client/")) urls.add(chunk);
-      }
-    }
-    return [...urls];
+  static #broadcastTrace(trace: HmrTrace | undefined): HmrTrace | undefined {
+    return trace ? { ...trace, broadcastAt: Date.now() } : undefined;
   }
 
   #createBuilderRpc() {
@@ -199,6 +185,8 @@ export class DevHmrController {
       },
       onBuildStatus: (status) => {
         this.#recordBuildStatus(status);
+        
+        if (status.phase === "pages" && !status.ok) this.#ssrUpdates.release(status.generation);
       },
       onCsrUpdated: (update) => {
         this.#renderState.csrGeneration = update.generation;
@@ -209,11 +197,24 @@ export class DevHmrController {
           changedIds: update.changedIds,
           reload: update.reload,
           reason: update.reason,
+          trace: DevHmrController.#broadcastTrace(update.trace),
         });
         this.#logger.verbose(
           `[csr] ${update.mode} generation=${update.generation} ${update.reload ? `reload (${update.reason ?? "no reason"})` : `patch modules=${update.changedIds?.length ?? 0}`}`,
         );
       },
+      onSsrUpdated: (update) => {
+        if (update.epoch !== undefined) this.#renderState.ssrEpoch = update.epoch;
+        if (update.first) {
+          this.#renderState.ssrGeneration = update.generation;
+          this.#logger.verbose(`[ssr] registry built generation=${update.generation}`);
+          return;
+        }
+        this.#ssrUpdates.push(update);
+        this.#logger.verbose(
+          `[ssr] registry generation=${update.generation} ${update.reload ? `reload (${update.reason ?? "no reason"})` : `patch modules=${update.changedIds?.length ?? 0}`}${this.#ssrUpdates.size > 0 ? ` held=${this.#ssrUpdates.size} until the pages build of batch ${update.batchGeneration ?? "?"}` : ""}`,
+        );
+      },
       onCssUpdated: (css) => {
         const started = Date.now();
         const cssBytesByUrl = Object.fromEntries(
@@ -226,38 +227,94 @@ export class DevHmrController {
         this.#renderState.cssBytesByUrl = cssBytesByUrl;
         this.#rsc.updateCssAssets(this.#renderState.cssAssets);
         this.#hub.broadcast({ type: "css-update", cssAssets: this.#renderState.cssAssets });
+        void this.#pruner.pruneStyles(this.#renderState.cssAssets);
         this.#logger.verbose(
           `css-update assets=${Object.keys(this.#renderState.cssAssets).length} generation=${css.generation ?? "(unknown)"} files=${css.changedFiles?.length ?? 0} in ${Date.now() - started}ms (ipc)`,
         );
       },
-      onPagesUpdated: async ({ bundlePath, buildId, generation, changedFiles }) => {
+      onPagesUpdated: async ({ bundlePath, buildId, generation, changedFiles, trace, serverTouched }) => {
         const started = Date.now();
         const files = changedFiles ?? [];
         const routeTreeChanged = await this.#reloadSeedIndex();
         const runtimeMetadataChanged = files.some(isAkanRuntimeMetadataFile);
         const clearAll = routeTreeChanged || runtimeMetadataChanged;
-        const staleClientEntries = clearAll ? new Set<string>() : this.#staleClientEntriesForFiles(files);
+        const lateFiles = files.filter((file) => !this.#earlyInvalidated.has(path.resolve(file)));
+        
+        for (const [file, early] of this.#earlyInvalidated)
+          if (generation === undefined || early <= generation) this.#earlyInvalidated.delete(file);
+        const staleClientEntries = clearAll ? new Set<string>() : this.#staleClientEntriesForFiles(lateFiles);
         const routeIds = clearAll ? undefined : this.#routeIdsForFiles(files, staleClientEntries);
-        const fastRefreshCandidate = !clearAll && this.#isFastRefreshCandidate(files);
         this.#logger.verbose(
-          `[SSR] pages-updated bundlePath=${bundlePath} buildId=${buildId} generation=${generation ?? "(unknown)"} files=${files.length} routes=${routeIds?.length ?? 0} fastRefresh=${fastRefreshCandidate} staleEntries=${staleClientEntries.size} runtimeMetadata=${runtimeMetadataChanged} routeTree=${routeTreeChanged}`,
+          `[SSR] pages-updated bundlePath=${bundlePath} buildId=${buildId} generation=${generation ?? "(unknown)"} files=${files.length} routes=${routeIds?.length ?? 0} serverTouched=${serverTouched ?? "(unknown)"} staleEntries=${staleClientEntries.size} runtimeMetadata=${runtimeMetadataChanged} routeTree=${routeTreeChanged}`,
         );
-        const dropped = this.#invalidateRoutes(files, routeIds, staleClientEntries, { forceClear: clearAll });
-        this.#renderState.buildId = buildId;
+        const dropped =
+          clearAll || lateFiles.length > 0
+            ? this.#invalidateRoutes(
+                lateFiles,
+                this.#routeIdsForFiles(lateFiles, staleClientEntries),
+                staleClientEntries,
+                { forceClear: clearAll, batch: generation },
+              )
+            : [];
         const manifest = this.routeCache.snapshot();
-        const reloadStarted = Date.now();
-        await this.#rsc.reload({
-          clientManifest: manifest.clientManifest,
-          cssAssets: this.#renderState.cssAssets,
-          buildId,
-          pagesBundlePath: bundlePath,
-        });
-        this.#logger.verbose(`[SSR] rsc reload buildId=${buildId} in ${Date.now() - reloadStarted}ms`);
+
+        const running = bundlePath ? path.resolve(bundlePath) : null;
+        let tabBuildId = buildId;
+        if (serverTouched === false && !clearAll && running === this.#runningBundlePath) {
+          this.#logger.verbose(
+            `[SSR] pages bundle unchanged for the server; buildId ${this.#renderState.buildId} kept`,
+          );
+        } else {
+          const previousBuildId = this.#renderState.buildId;
+          this.#renderState.buildId = buildId;
+          const reloadStarted = Date.now();
+          try {
+            const adopted = await this.#rsc.reload({
+              clientManifest: manifest.clientManifest,
+              cssAssets: this.#renderState.cssAssets,
+              buildId,
+              pagesBundlePath: bundlePath,
+            });
+            this.#adoptBundle(adopted.pagesBundlePath);
+            
+            tabBuildId = adopted.buildId;
+          } catch (error) {
+            const failure = DevHmrController.#reloadFailure(error);
+            
+            if (failure) {
+              this.#renderState.buildId = failure.adopted.buildId;
+              this.#adoptBundle(failure.adopted.pagesBundlePath);
+            } else if (this.#renderState.buildId === buildId) this.#renderState.buildId = previousBuildId;
+            
+            if (failure?.adopted.buildId !== buildId) {
+
+              if (failure && failure.failed.buildId !== buildId) this.#ssrUpdates.release(generation);
+              else this.#failPagesReload(generation, files, error);
+              return;
+            }
+          }
+          this.#logger.verbose(`[SSR] rsc reload buildId=${buildId} in ${Date.now() - reloadStarted}ms`);
+        }
         const shouldReload = clearAll || this.#shouldFullReloadForFiles(files, routeIds);
-        if (shouldReload) this.#hub.broadcast({ type: "reload", buildId });
-        else if (fastRefreshCandidate)
-          this.#hub.broadcast({ type: "client-refresh", buildId, generation, changedFiles, routeIds });
-        else this.#hub.broadcast({ type: "rsc-refresh", buildId, generation, changedFiles, routeIds });
+        const broadcastTrace = DevHmrController.#broadcastTrace(trace);
+        if (shouldReload) this.#ssrUpdates.clear(generation);
+        const released = shouldReload ? { released: 0, reload: false } : this.#ssrUpdates.release(generation);
+        if (shouldReload) this.#hub.broadcast({ type: "reload", buildId: tabBuildId });
+        else if (released.reload)
+          this.#logger.verbose(`[hmr] generation=${generation} released a registry reload; no RSC refresh needed`);
+        else if (serverTouched === false)
+          this.#logger.verbose(
+            `[hmr] generation=${generation} changed nothing the server renders; the registry patched it`,
+          );
+        else
+          this.#hub.broadcast({
+            type: "rsc-refresh",
+            buildId: tabBuildId,
+            generation,
+            changedFiles,
+            routeIds,
+            trace: broadcastTrace,
+          });
         this.#logger.verbose(
           `[hmr] backend apply buildId=${buildId} dropped=${dropped.length} routeGeneration=${manifest.generation} in ${Date.now() - started}ms`,
         );
@@ -265,6 +322,24 @@ export class DevHmrController {
     });
   }
 
+  #adoptBundle(bundlePath: string): void {
+    const running = path.resolve(bundlePath);
+    if (running === this.#runningBundlePath) return;
+    this.#runningBundlePath = running;
+    void this.#pruner.prunePages(running);
+  }
+
+  static #reloadFailure(error: unknown): RscReloadFailure | null {
+    return error instanceof Error && "adopted" in error ? (error as RscReloadFailure) : null;
+  }
+
+  #failPagesReload(generation: number | undefined, files: string[], error: unknown): void {
+    const message = error instanceof Error ? error.message : String(error);
+    this.#logger.error(`[SSR] rsc reload failed generation=${generation ?? "(unknown)"}: ${message}`);
+    if (generation !== undefined) this.#recordBuildStatus({ generation, phase: "pages", ok: false, files, message });
+    this.#ssrUpdates.release(generation);
+  }
+
   async #reloadSeedIndex(): Promise<boolean> {
     const next = await RouteSeedIndexStore.load(this.#artifactDir).catch((err: unknown) => {
       this.#logger.warn(`[hmr] route seed index unreadable; keeping the boot one: ${String(err)}`);
@@ -281,9 +356,12 @@ export class DevHmrController {
   }
 
   #recordBuildStatus(status: DevBuildStatus): void {
+    this.#recheckFailedRoute(status);
     const previous = this.#buildStatusByPhase.get(status.phase);
-    this.#buildStatusByPhase.set(status.phase, status);
     const message = devBuildStatusToHmrMessage(status, previous);
+
+    if (status.ok && previous && !previous.ok && !message) return;
+    this.#buildStatusByPhase.set(status.phase, status);
     if (!message) return;
     this.#hub.broadcast(message);
     this.#logger.verbose(
@@ -291,6 +369,26 @@ export class DevHmrController {
     );
   }
 
+  #recheckFailedRoute(status: DevBuildStatus, { again = false }: { again?: boolean } = {}): void {
+    if (!status.ok || (status.phase !== "pages" && status.phase !== "ssr")) return;
+    if (this.#recheckingRoute) {
+      this.#recheckAgain = status;
+      return;
+    }
+    const failed = this.#buildStatusByPhase.get("route");
+    if (!failed || failed.ok || !failed.scope || (!again && failed.generation >= status.generation)) return;
+    this.#recheckingRoute = true;
+    void this.routeCache
+      .ensure(failed.scope, failed.files)
+      .catch(() => undefined)
+      .finally(() => {
+        this.#recheckingRoute = false;
+        const next = this.#recheckAgain;
+        this.#recheckAgain = null;
+        if (next) this.#recheckFailedRoute(next, { again: true });
+      });
+  }
+
   #createRouteCache() {
     return new RouteClientCache({
       buildRoute: async (routeId, { seeds, knownEntries, generation }) => {
@@ -314,11 +412,19 @@ export class DevHmrController {
         }
         if (delta.newEntries.length === 0 && removedEntries.size === 0) return;
         this.#rememberClientDeps(routeId, delta.clientDeps, delta.clientDepsByEntry);
-        await this.#rsc.reload({
-          clientManifest: nextMerged.clientManifest,
-          cssAssets: this.#renderState.cssAssets,
-          buildId: this.#renderState.buildId,
-        });
+        try {
+          const adopted = await this.#rsc.reload({
+            clientManifest: nextMerged.clientManifest,
+            cssAssets: this.#renderState.cssAssets,
+            buildId: this.#renderState.buildId,
+          });
+          this.#adoptBundle(adopted.pagesBundlePath);
+        } catch (error) {
+
+          const failure = DevHmrController.#reloadFailure(error);
+          if (failure) this.#adoptBundle(failure.adopted.pagesBundlePath);
+          this.#logger.warn(`[SSR] route ${routeId} merged, but the worker did not reload: ${String(error)}`);
+        }
         this.#logger.verbose(
           `[SSR] route manifest merged routeId=${routeId} generation=${generation} entries=+${delta.newEntries.length} deps=${delta.clientDeps.length}`,
         );
@@ -327,6 +433,7 @@ export class DevHmrController {
   }
 
   #recordInvalidate(files: string[], kinds: Set<Exclude<ChangeKind, "ignore">>, generation?: number) {
+    if (kinds.has("code")) this.#invalidateClientEntriesEarly(files, generation ?? 0);
     for (const k of kinds) this.#dirty.add(k);
     for (const file of files) this.#dirtyFiles.add(file);
     if (this.#dirty.has("config")) {
@@ -352,11 +459,35 @@ export class DevHmrController {
     this.#dirtyFiles.clear();
   }
 
+  #invalidateClientEntriesEarly(files: string[], generation: number): void {
+    const staleClientEntries = this.#staleClientEntriesForFiles(files);
+
+    if (staleClientEntries.size === 0) {
+      this.routeCache.invalidateClientEntries({
+        routePredicate: () => false,
+        staleEntries: [],
+        files,
+        batch: generation,
+      });
+      return;
+    }
+
+    for (const file of files)
+      if (staleClientEntries.has(path.resolve(file))) this.#earlyInvalidated.set(path.resolve(file), generation);
+    const routeIds = this.#routeIdsForFiles(files, staleClientEntries);
+    this.routeCache.invalidateClientEntries({
+      routePredicate: (routeId) => !routeIds || routeIds.includes(routeId),
+      staleEntries: this.#clientEntryManifestKeys(staleClientEntries),
+      files,
+      batch: generation,
+    });
+  }
+
   #invalidateRoutes(
     files: string[],
     routeIds: string[] | undefined,
     staleClientEntries = new Set<string>(),
-    { forceClear = false }: { forceClear?: boolean } = {},
+    { forceClear = false, batch }: { forceClear?: boolean; batch?: number } = {},
   ): string[] {
     this.#dirty.clear();
     this.#dirtyFiles.clear();
@@ -366,10 +497,14 @@ export class DevHmrController {
       return this.routeCache.invalidateClientEntries({
         routePredicate: (routeId) => !routeIds || routeIds.includes(routeId),
         staleEntries: staleKeys,
+        files,
+        batch,
       });
     }
-    if (!routeIds || this.#shouldClearAllRoutes(files, routeIds)) return this.routeCache.clear();
-    return this.routeCache.invalidate((routeId) => routeIds.includes(routeId));
+
+    if (!routeIds || this.#shouldClearAllRoutes(files, routeIds))
+      return batch === undefined ? this.routeCache.clear() : this.routeCache.invalidate(() => true, { files, batch });
+    return this.routeCache.invalidate((routeId) => routeIds.includes(routeId), { files, batch });
   }
 
   #routeIdsForFiles(files: string[], staleClientEntries = new Set<string>()): string[] | undefined {
@@ -391,31 +526,16 @@ export class DevHmrController {
     return unique.length > 0 ? unique : undefined;
   }
 
-  #isFastRefreshCandidate(files: string[]): boolean {
-    if (!this.#fastRefreshEnabled || files.length === 0) return false;
-    if (manifestClientEntriesForFiles(files, this.routeCache.merged.clientManifest).size > 0) return true;
-    return files.some((file) => {
-      const resolved = path.resolve(file);
-      return this.#recentClientEntries.has(resolved) || this.#recentClientFiles.has(resolved);
-    });
-  }
-
   #rememberClientDeps(routeId: string, deps: string[], depsByEntry: Record<string, string[]> = {}) {
     for (const [entry, entryDeps] of Object.entries(depsByEntry)) {
       const resolvedEntry = path.resolve(entry);
       this.#recentClientEntries.add(resolvedEntry);
       DevHmrController.#addTo(this.#clientEntryRouteIds, resolvedEntry, routeId);
       for (const dep of entryDeps) {
-        const resolvedDep = path.resolve(dep);
-        this.#recentClientFiles.add(resolvedDep);
-        DevHmrController.#addTo(this.#clientFileEntries, resolvedDep, resolvedEntry);
+        DevHmrController.#addTo(this.#clientFileEntries, path.resolve(dep), resolvedEntry);
       }
     }
-    for (const dep of deps) {
-      const resolved = path.resolve(dep);
-      this.#recentClientFiles.add(resolved);
-      DevHmrController.#addTo(this.#clientFileRouteIds, resolved, routeId);
-    }
+    for (const dep of deps) DevHmrController.#addTo(this.#clientFileRouteIds, path.resolve(dep), routeId);
   }
 
   static #addTo(map: Map<string, Set<string>>, key: string, value: string) {
@@ -491,28 +611,4 @@ export class DevHmrController {
       files.some((file) => path.resolve(file).includes(`${path.sep}page${path.sep}`) && /\.(tsx|ts|jsx|js)$/.test(file))
     );
   }
-
-  static #clientFacingOrigin(req: Request): string {
-    const parsed = new URL(req.url);
-    const fwdProto = req.headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
-    const fwdHost = req.headers.get("x-forwarded-host")?.split(",")[0]?.trim();
-    const hostFallback = fwdHost ?? req.headers.get("host");
-    const protoFallback = fwdProto ?? parsed.protocol.slice(0, -1);
-    if (hostFallback && protoFallback) {
-      try {
-        return new URL(`${protoFallback}://${hostFallback}`).origin;
-      } catch {
-      }
-    }
-    return parsed.origin;
-  }
-
-  static #isTrustedRscTarget(clientOrigin: string, targetUrl: URL): boolean {
-    try {
-      if (targetUrl.origin === clientOrigin) return true;
-      return targetUrl.hostname === new URL(clientOrigin).hostname;
-    } catch {
-      return false;
-    }
-  }
 }

package/server/hmr/ssrDevShim.ts

@@ -0,0 +1,112 @@
+import { type CsrDevManifest, SSR_DEV_CHUNK, SSR_DEV_ID_PREFIX, SSR_DEV_ROUTE_PREFIX } from "./csrDevManifest";
+import { CSR_DEV_RUNTIME_SCRIPT } from "./csrDevRuntime";
+
+export class SsrDevShim {
+  static readonly runtimeUrl = `${SSR_DEV_ROUTE_PREFIX}runtime.js?v=${Bun.hash(CSR_DEV_RUNTIME_SCRIPT).toString(36)}`;
+  static readonly #body = `var baseLoad = self.__webpack_chunk_load__;
+  var baseRequire = self.__webpack_require__;
+  var booting = null;
+  var built = null;
+  function wait(ms) {
+    return new Promise(function (resolve) { setTimeout(resolve, ms); });
+  }
+  function script(src) {
+    return new Promise(function (resolve, reject) {
+      var el = document.createElement("script");
+      el.src = src;
+      el.async = false;
+      el.onload = function () { resolve(); };
+      el.onerror = function () { reject(new Error("[akan-ssr-dev] " + src + " failed to load")); };
+      document.head.appendChild(el);
+    });
+  }
+  function state() {
+    return fetch(c.prefix + "boot.json?wait=10000", { cache: "no-store" }).then(function (res) {
+      return res.ok ? res.json() : wait(1000).then(state);
+    }, function () {
+      return wait(1000).then(state);
+    });
+  }
+  function load(vendors, attempt) {
+    self.__AKAN_SSR_EPOCH__ = built.epoch;
+    return Promise.all([vendors, script(c.prefix + built.vendorFile)]).then(function () {
+      return script(c.prefix + "app.js?g=" + built.generation);
+    }).catch(function (error) {
+      if (attempt >= 3) throw error;
+      return wait(500).then(state).then(function (next) {
+        built = next;
+        return load(vendors, attempt + 1);
+      });
+    });
+  }
+  function reloadOnto(vendorFile, attempt) {
+    return state().then(function (current) {
+      if (current.vendorFile === vendorFile) {
+        self.location.reload();
+        return new Promise(function () {});
+      }
+      if (attempt < 4) return wait(500).then(function () { return reloadOnto(vendorFile, attempt + 1); });
+    });
+  }
+  function catchUp() {
+    var hello = self.__AKAN_SSR_HELLO_GENERATION__;
+    if (typeof hello === "number") self.__akan.catchUp(hello, c.prefix);
+  }
+  function runtime(attempt) {
+    return script(c.runtime).catch(function (error) {
+      if (attempt >= 3) throw error;
+      return wait(500).then(state).then(function () { return runtime(attempt + 1); });
+    });
+  }
+  function boot() {
+    if (!booting)
+      booting = self.__AKAN_SSR_BOOT__ = runtime(0).then(function () {
+        var early = self.__AKAN_SSR_EARLY_UPDATES__ || [];
+        self.__AKAN_SSR_EARLY_UPDATES__ = null;
+        for (var i = 0; i < early.length; i++) self.__akan.hot(early[i]);
+        return c.vendorFile ? c : state();
+      }).then(function (current) {
+        built = current;
+        return load(Promise.all(c.vendors.map(function (specifier) {
+          return import(specifier).then(function (ns) { self.__akan.provide("vendor:" + specifier, ns); });
+        })), 0);
+      }).then(function () {
+        var started = self.__akan.inspect();
+        if (typeof started.epoch === "number") self.__AKAN_SSR_EPOCH__ = started.epoch;
+        var vendorFile = started.vendorFile;
+        if (!vendorFile || vendorFile === built.vendorFile) return catchUp();
+        if (started.failed) return reloadOnto(vendorFile, 0);
+        return script(c.prefix + vendorFile).then(catchUp, function () { return reloadOnto(vendorFile, 0); });
+      }).catch(function (error) {
+        var failed = built || c;
+        self.__AKAN_SSR_BOOT_FAILED__ = { generation: failed.generation || 0, epoch: failed.epoch };
+        throw error;
+      });
+    return booting;
+  }
+  self.__webpack_chunk_load__ = function (id) { return id === c.chunk ? boot() : baseLoad(id); };
+  var require = function (id) {
+    if (typeof id !== "string" || id.indexOf(c.idPrefix) !== 0) return baseRequire(id);
+    var moduleId = id.slice(c.idPrefix.length);
+    var registry = self.__akan;
+    if (registry.has(moduleId)) return registry.require(moduleId);
+    return registry.whenDefined(moduleId).then(function () { return registry.require(moduleId); });
+  };
+  require.u = baseRequire.u;
+  self.__webpack_require__ = require;`;
+
+  /** `vendors` are the import map's specifiers: the registry requires them as `vendor:<specifier>`, never compiles them. */
+  static script(manifest: CsrDevManifest | null, vendors: string[]): string {
+    const config = {
+      chunk: SSR_DEV_CHUNK,
+      idPrefix: SSR_DEV_ID_PREFIX,
+      prefix: SSR_DEV_ROUTE_PREFIX,
+      runtime: SsrDevShim.runtimeUrl,
+      generation: manifest?.generation ?? 0,
+      vendorFile: manifest?.vendorFile ?? null,
+      epoch: manifest?.epoch ?? null,
+      vendors,
+    };
+    return `(function (c) {\n  ${SsrDevShim.#body}\n})(${JSON.stringify(config)});`;
+  }
+}