@pylonsync/functions 0.22.59 → 0.22.61

package/src/ssr-client-bundler.ts

@@ -42,7 +42,7 @@ import {
   type ManifestBuildConfig,
 } from "./build-compat";
 import { serverBundle } from "./server-bundle";
-import { declaresClientNavigation } from "./ssr-client-nav";
+import { declaresClientNavigation, stripComments } from "./ssr-client-nav";
 import { precompressBuild } from "./ssr-precompress";
 import { parseNamespaceBarrel, rewriteBarrelImports } from "./ssr-barrel-imports";
 import { buildOfflineWorker, readManifestOffline, type BundleOffline } from "./ssr-offline";
@@ -362,6 +362,9 @@ export const CLIENT_RUNTIME_SOURCE = `// Generated by Pylon SSR (Phase 2 client
 import { createElement, Fragment, Suspense } from "react";
 import { hydrateRoot } from "react-dom/client";
 import { configureClient, registerOfflineWorker } from "@pylonsync/react";
+// A namespace import for what an older @pylonsync/react may not export, so
+// an app on it still builds (the missing export is undefined).
+import * as pylonReact from "@pylonsync/react";
 import { createPylonBoundary, nearestBoundaryComponent } from "./client-boundary";
 import { LOADING_MODULES } from "./loading-registry";
 import { createNavPayloadCache } from "./nav-cache";
@@ -380,6 +383,9 @@ let currentComponent = null;
 let pendingNav = null;
 let manifestPromise = null;
 const prefetchedChunks = new Set();
+// The build this page runs (the service worker version from
+// __PYLON_DATA__), or null in an app without \`buildManifest({ offline })\`.
+let pageBuild = null;
 
 function buildTree(Page, Layouts, props, loadingFor) {
   let tree = createElement(Page, props);
@@ -610,17 +616,64 @@ function readPylonData() {
   }
 }
 
+// The build manifest of this page's build. A manifest of another build is
+// not used: its route files cannot run next to this page's (two copies of
+// React, a layout from each build). That happens when an older service
+// worker answers from its cache, or when the server already runs a newer
+// build. Navigation then moves the page to the server's build
+// (moveToLatestBuild). A failed fetch is not kept, so the next call asks
+// again.
 async function loadManifest() {
   if (!manifestPromise) {
-    manifestPromise = fetch("/_pylon/build/manifest.json", {
+    const pending = fetch("/_pylon/build/manifest.json", {
       credentials: "same-origin",
     })
       .then((r) => (r.ok ? r.json() : null))
-      .catch(() => null);
+      .catch(() => null)
+      .then((manifest) => {
+        if (!manifest && manifestPromise === pending) manifestPromise = null;
+        const build = manifest && manifest.offline && manifest.offline.version;
+        if (build && pageBuild && build !== pageBuild) {
+          console.warn(
+            "[pylon ssr] the build manifest is for build " + build +
+              ", and this page runs build " + pageBuild + ". Not using it.",
+          );
+          return null;
+        }
+        return manifest;
+      });
+    manifestPromise = pending;
   }
   return manifestPromise;
 }
 
+// Move this page to the server's build when it runs another one (see
+// moveToLatestBuild in @pylonsync/react): the outbox is sent first, the
+// waiting service worker takes over, and \`url\` loads once. Resolves with
+// what happened: "moving", "current", "offline", "pending-writes",
+// "blocked", or "inert" (no offline build, or an older @pylonsync/react).
+function moveToLatestBuild(options) {
+  const move = pylonReact.moveToLatestBuild;
+  if (typeof move !== "function") return Promise.resolve("inert");
+  return move(options).catch((e) => {
+    console.warn("[pylon ssr] could not move to the new build:", e);
+    return "inert";
+  });
+}
+
+// A route entry failed to load, or the server answered with a page of
+// another build. True when navigate() is done: the page is loading the
+// server's build, or the device is offline and the page keeps its screen.
+// False when the caller falls back to a full page load (the server runs
+// this build, or the page already moved and is still on it).
+async function movedForFailedRoute(href) {
+  const result = await moveToLatestBuild({ url: href, recheck: true });
+  if (result === "offline") {
+    console.warn("[pylon ssr] offline: " + href + " cannot open now.");
+  }
+  return result === "moving" || result === "offline";
+}
+
 function preloadChunks(routeInfo) {
   if (!routeInfo) return;
   const prefix = routeInfo.public_prefix || "/_pylon/build/";
@@ -782,6 +835,7 @@ export function hydrate(component, Page, Layouts, metadata) {
       );
       return;
     }
+    pageBuild = (data.offline && data.offline.version) || null;
     setNavParams(data);
     currentPageProps = withClientProps(data);
     currentComponent = data.component;
@@ -936,6 +990,15 @@ async function navigate(href, opts) {
   // timer that fires late can never paint a skeleton over real content.
   const navState = { settled: false };
 
+  // ---- New build -----------------------------------------------------------
+  // The last check found a newer build on the server: open the link in it
+  // instead of rendering it with this page's build, whose files the deploy
+  // removed. Not while writes wait to be sent; a failure below moves then.
+  if (activeRoot) {
+    const early = await moveToLatestBuild({ url: href, skipIfPendingWrites: true });
+    if (early === "moving" || myEpoch !== navEpoch) return;
+  }
+
   // ---- Instant navigation --------------------------------------------------
   // A route whose page exports \`navigation = "client"\`, or whose URL is an
   // offline route, renders from the client with no page fetch: its data comes
@@ -950,8 +1013,11 @@ async function navigate(href, opts) {
       try {
         route = await loadRouteEntry(matched.component);
       } catch (e) {
-        // Fall through to the fetch below, which reloads the page when the
-        // entry cannot load.
+        // After a deploy: move to the new build. Offline: keep the screen.
+        // Otherwise fall through to the fetch below, which reloads the page
+        // when the entry cannot load.
+        if (myEpoch !== navEpoch) return;
+        if (await movedForFailedRoute(href)) return;
         console.warn("[pylon ssr] client navigation fell back to a page fetch:", e);
       }
       if (myEpoch !== navEpoch) return;
@@ -1090,15 +1156,29 @@ async function navigate(href, opts) {
     fullLoad();
     return;
   }
-  let route;
-  try {
-    route = await loadRouteEntry(data.component);
-  } catch (e) {
-    console.warn("[pylon ssr] nav fallback (entry load failed):", e);
+  // The server runs another build: this page's route files cannot render
+  // its pages.
+  const otherBuild =
+    pageBuild && data.offline && data.offline.version && data.offline.version !== pageBuild;
+  let route = null;
+  if (!otherBuild) {
+    try {
+      route = await loadRouteEntry(data.component);
+    } catch (e) {
+      console.warn("[pylon ssr] nav fallback (entry load failed):", e);
+    }
+  }
+  if (myEpoch !== navEpoch) return;
+  if (!route) {
+    if (await movedForFailedRoute(href)) {
+      navState.settled = true;
+      if (placeholderTimer) clearTimeout(placeholderTimer);
+      return;
+    }
+    if (myEpoch !== navEpoch) return;
     fullLoad();
     return;
   }
-  if (myEpoch !== navEpoch) return;
   navState.settled = true;
   if (placeholderTimer) clearTimeout(placeholderTimer);
   document.title = doc.title || document.title;
@@ -1375,9 +1455,10 @@ function readComponentSource(fs: any, path: any, cwd: string, component: string)
  *  it to the runtime, which takes the title from it on a navigation with no
  *  page fetch. A static scan, so a page without one imports nothing extra. */
 export function exportsStaticMetadata(source: string): boolean {
+  const code = stripComments(source);
   return (
-    /\bexport\s+(?:const|let|var)\s+metadata\b/.test(source) ||
-    /\bexport\s*\{[^}]*\bmetadata\b[^}]*\}/.test(source)
+    /\bexport\s+(?:const|let|var)\s+metadata\b/.test(code) ||
+    /\bexport\s*\{[^}]*\bmetadata\b[^}]*\}/.test(code)
   );
 }
 
@@ -2021,36 +2102,9 @@ export async function _doBuildInner(
       // against; the build itself is fine.
     }
 
-    // Scan a built JS file for STATIC `import` literals pointing at
-    // `./chunks/<file>.js` and return them resolved to outdir-relative paths.
-    // Bun's minified output uses simple double quotes for module specifiers,
-    // so a `matchAll` covers both `import X from "Y"` and bare `import "Y"`.
-    //
-    // DYNAMIC `import("Y")` is deliberately NOT matched. This list becomes the
-    // route's modulepreload set, and a chunk the author deferred behind
-    // `import()` must not be downloaded eagerly anyway — that would split the
-    // code out of the entry (so it isn't parsed on load) while still shipping
-    // every byte, which is the expensive half of the cost with none of the
-    // saving. The trailing `(` is what distinguishes the two forms.
-    function scanChunkImports(jsAbsPath: string): string[] {
-      let src: string;
-      try {
-        src = fs.readFileSync(jsAbsPath, "utf8");
-      } catch {
-        return [];
-      }
-      const found = new Set<string>();
-      const matches = src.matchAll(/(?:from\s*|import\s*)["']([^"']+)["']/g);
-      for (const m of matches) {
-        const spec = m[1];
-        if (spec.startsWith("./chunks/") || spec.startsWith("chunks/")) {
-          const base = path.basename(spec);
-          const hit = chunksByBasename.get(base);
-          if (hit) found.add(hit.relPath);
-        }
-      }
-      return Array.from(found);
-    }
+    const chunkRelPaths = new Set(
+      Array.from(chunksByBasename.values()).map((c) => c.relPath),
+    );
 
     const manifest: PylonBundleManifest = {
       build_id: makeBuildId(),
@@ -2064,22 +2118,9 @@ export async function _doBuildInner(
       const stem = `client-entry-${slug}`;
       const entry = entriesByStem.get(stem);
       if (!entry) continue;
-      // Walk transitively in case Bun emits chunks that reference
-      // other chunks (rare in the single-level splitting we use,
-      // but free to compute).
-      const seen = new Set<string>();
-      const queue: string[] = scanChunkImports(entry.absPath);
-      for (const q of queue) seen.add(q);
-      while (queue.length > 0) {
-        const relChunk = queue.shift()!;
-        const absChunk = path.join(outdir, relChunk);
-        for (const nested of scanChunkImports(absChunk)) {
-          if (!seen.has(nested)) {
-            seen.add(nested);
-            queue.push(nested);
-          }
-        }
-      }
+      // The SSR head modulepreloads every file in the static graph, so the
+      // browser fetches them in parallel instead of level by level.
+      const seen = staticImportGraph(fs, path, outdir, entry.absPath, chunkRelPaths);
       manifest.routes[r.component] = {
         file: entry.relPath,
         imports: Array.from(seen),
@@ -2372,6 +2413,65 @@ const ASSET_RE = /\.(wasm|png|jpe?g|gif|webp|avif|ico|svg|woff2?|ttf|otf|mp3|mp4
  * the absolute URL. A stylesheet's `url(...)` is left to Bun: CSS cannot
  * import a JavaScript module.
  */
+/**
+ * The outdir-relative chunks a built entry reaches through STATIC imports,
+ * nearest first. Specifiers are relative to the importing file: an entry
+ * imports `./chunks/<file>.js`, a chunk imports its siblings as
+ * `./<file>.js`. Following only the first form dropped every chunk-to-chunk
+ * import, so those chunks were missing from the route's modulepreload set
+ * and loaded in a second wave (3 of 28 files on the Veritas home page).
+ *
+ * DYNAMIC `import("Y")` is deliberately not followed. This list becomes the
+ * route's modulepreload set, and a chunk the author deferred behind
+ * `import()` must not be downloaded eagerly: that would ship every byte the
+ * split was meant to defer. The trailing `(` tells the forms apart; Bun's
+ * minified output quotes specifiers plainly, so one pattern covers
+ * `import X from "Y"`, `import{a}from"Y"` and bare `import "Y"`.
+ */
+export function staticImportGraph(
+  fs: any,
+  path: any,
+  outdir: string,
+  entryAbsPath: string,
+  chunkRelPaths: Set<string>,
+): Set<string> {
+  const toUrlPath = (p: string) => p.replace(/\\/g, "/");
+  const scan = (jsAbsPath: string): string[] => {
+    let src: string;
+    try {
+      src = fs.readFileSync(jsAbsPath, "utf8");
+    } catch {
+      return [];
+    }
+    const found = new Set<string>();
+    const dir = path.dirname(jsAbsPath);
+    for (const m of src.matchAll(/(?:from\s*|import\s*)["']([^"']+)["']/g)) {
+      const spec = m[1]!;
+      if (!spec.startsWith("./") && !spec.startsWith("../") && !spec.startsWith("chunks/")) {
+        continue;
+      }
+      const rel = toUrlPath(
+        path.relative(outdir, path.resolve(spec.startsWith("chunks/") ? outdir : dir, spec)),
+      );
+      if (chunkRelPaths.has(rel)) found.add(rel);
+    }
+    return Array.from(found);
+  };
+  const seen = new Set<string>();
+  const queue = scan(entryAbsPath);
+  for (const q of queue) seen.add(q);
+  while (queue.length > 0) {
+    const rel = queue.shift()!;
+    for (const nested of scan(path.join(outdir, rel))) {
+      if (!seen.has(nested)) {
+        seen.add(nested);
+        queue.push(nested);
+      }
+    }
+  }
+  return seen;
+}
+
 /**
  * Rewrite named imports from namespace barrels (`radix-ui`) in app source
  * into imports of the re-exported packages, so a route bundles only the

package/src/ssr-client-nav-runtime.fixture.ts

@@ -24,11 +24,33 @@ const MANIFEST = {
     "app/fast/page": { file: "fast.js", imports: [], css: [], path: "/fast", navigation: "client" },
     "app/slow/page": { file: "slow.js", imports: [], css: [], path: "/slow" },
     "app/offline/page": { file: "offline.js", imports: [], css: [], path: "/offline" },
+    // Never registered by a test hydrate() call, and their files do not
+    // exist: loading them fails like a file the deploy removed.
+    "app/reports/page": { file: "reports-v1.js", imports: [], css: [], path: "/reports" },
+    "app/quick/page": { file: "quick-v1.js", imports: [], css: [], path: "/quick", navigation: "client" },
   },
   offline: { routes: ["/offline"] },
 };
 
-const LINKS = ["/", "/fast", "/slow", "/offline"];
+/** \`stale-manifest\`: the page runs build v1, and the build manifest it gets
+ *  is build v0's, as an older service worker answers from its cache. */
+const MODE = process.argv[2] ?? "default";
+
+/** Build v0's manifest: other files for the same routes. */
+const STALE_MANIFEST = {
+  ...MANIFEST,
+  routes: Object.fromEntries(
+    Object.entries(MANIFEST.routes).map(([k, v]) => [k, { ...v, file: v.file.replace(/(-v1)?\.js$/, "-v0.js") }]),
+  ),
+  offline: { ...MANIFEST.offline, version: "v0" },
+};
+
+/** The page's build: the home page's __PYLON_DATA__ carries it. */
+const PAGE_BUILD = "v1";
+/** The build the server runs after the deploy. */
+let serverBuild = "v1";
+
+const LINKS = ["/", "/fast", "/slow", "/offline", "/reports", "/quick"];
 
 function Layout({ children }: { children?: React.ReactNode }) {
   return React.createElement(
@@ -65,16 +87,25 @@ const Offline = page("offline");
 
 const fetches: string[] = [];
 const scrolls: number[] = [];
+/** Full page loads (\`location.href = ...\`) the runtime started. */
+const fullLoads: string[] = [];
+/** Calls to @pylonsync/react's moveToLatestBuild, and its answer. */
+const moves: any[] = [];
+let moveResult = "moving";
+/** The server's build as the page's updater last saw it: a recheck asks
+ *  the server; null until then (no check has run). */
+let knownBuild: string | null = null;
 let win: any;
 let rt: any;
 let dir = "";
 
-function pylonData(component: string, pathname: string): string {
+function pylonData(component: string, pathname: string, build = serverBuild): string {
   const data = {
     component,
     layouts: [],
     props: { pathname, url: pathname, params: {}, searchParams: {} },
     ssrData: {},
+    offline: { version: build },
   };
   return `<script id="__PYLON_DATA__" type="application/json">${JSON.stringify(data)}</script>`;
 }
@@ -108,18 +139,29 @@ async function setUp() {
   dir = fs.mkdtempSync(path.join(cacheDir, "pylon-client-nav-"));
   await writeClientRuntimeModules(fs, path, dir);
   // @pylonsync/react is not a dependency of this package: stand in for the
-  // two functions the runtime calls at hydration.
+  // functions the runtime calls.
   const runtimeFile = path.join(dir, "client-runtime.ts");
   fs.writeFileSync(
     runtimeFile,
     fs
       .readFileSync(runtimeFile, "utf8")
-      .replace('from "@pylonsync/react"', 'from "./pylon-react-stub"'),
+      .replaceAll('from "@pylonsync/react"', 'from "./pylon-react-stub"'),
   );
   fs.writeFileSync(
     path.join(dir, "pylon-react-stub.ts"),
-    "export function configureClient() {}\nexport async function registerOfflineWorker() { return null; }\n",
+    "export function configureClient() {}\n" +
+      "export async function registerOfflineWorker() { return null; }\n" +
+      "export function moveToLatestBuild(options) { return globalThis.__moveToLatestBuild(options); }\n",
   );
+  // Answers like AppUpdater.moveToLatestBuild: from the last check, or
+  // from the server on a recheck.
+  (globalThis as any).__moveToLatestBuild = async (options: any) => {
+    moves.push(options);
+    if (options.recheck) knownBuild = serverBuild;
+    if (knownBuild === null) return "offline";
+    if (knownBuild === PAGE_BUILD) return "current";
+    return moveResult;
+  };
   fs.writeFileSync(path.join(dir, "loading-registry.ts"), "export const LOADING_MODULES = {};\n");
 
   win = new Window({ url: "http://localhost/" });
@@ -138,11 +180,22 @@ async function setUp() {
   g.requestAnimationFrame = (cb: any) => setTimeout(() => cb(Date.now()), 0);
   g.cancelAnimationFrame = (id: any) => clearTimeout(id);
   win.scrollTo = (_x: number, y: number) => scrolls.push(y);
+  // Record full page loads instead of letting happy-dom navigate.
+  const hrefDescriptor = Object.getOwnPropertyDescriptor(
+    Object.getPrototypeOf(win.location),
+    "href",
+  )!;
+  Object.defineProperty(win.location, "href", {
+    configurable: true,
+    get: () => hrefDescriptor.get!.call(win.location),
+    set: (value: string) => fullLoads.push(value),
+  });
   const fakeFetch = async (input: any) => {
     const url = typeof input === "string" ? input : input.url;
     fetches.push(url);
     if (url === "/_pylon/build/manifest.json") {
-      return new Response(JSON.stringify(MANIFEST), { status: 200 });
+      const body = MODE === "stale-manifest" ? STALE_MANIFEST : MANIFEST;
+      return new Response(JSON.stringify(body), { status: 200 });
     }
     const pathname = new URL(url, "http://localhost").pathname;
     if (pathname === "/slow") {
@@ -151,6 +204,12 @@ async function setUp() {
         { status: 200 },
       );
     }
+    if (pathname === "/reports") {
+      return new Response(
+        `<!DOCTYPE html><html><head><title>Reports</title></head><body>${pylonData("app/reports/page", pathname)}</body></html>`,
+        { status: 200 },
+      );
+    }
     return new Response("not found", { status: 404 });
   };
   g.fetch = fakeFetch;
@@ -160,7 +219,7 @@ async function setUp() {
   const props = { pathname: "/", url: "/", params: {}, searchParams: {} };
   const html = renderToString(React.createElement(Layout, null, React.createElement(Home, props)));
   const parsed = new win.DOMParser().parseFromString(
-    "<!DOCTYPE html>" + html.replace("</body>", pylonData("app/home/page", "/") + "</body>"),
+    "<!DOCTYPE html>" + html.replace("</body>", pylonData("app/home/page", "/", PAGE_BUILD) + "</body>"),
     "text/html",
   );
   // Remove, then append: happy-dom 20's replaceChild inserts the new root
@@ -245,7 +304,102 @@ async function prefetchTiming() {
   const intent = preloads().length - beforeSave;
   return { sightBeforeIdle, sightAfterIdle, saveDataSight, intent };
 }
-try {
+/** A deploy while the page is open: its build's route files are gone. */
+async function afterDeploy() {
+  const out: Record<string, any> = {};
+  const take = () => {
+    const seen = {
+      moves: moves.splice(0),
+      fullLoads: fullLoads.splice(0),
+      heading: heading() ?? null,
+      pageFetches: pageFetches(),
+    };
+    fetches.length = 0;
+    return seen;
+  };
+  take();
+
+  // Before the deploy, a route entry that fails to load (a bug, not a
+  // deploy) still falls back to one full page load.
+  click("toreports");
+  await settle();
+  out.sameBuildFailure = take();
+
+  serverBuild = "v2";
+  knownBuild = null;
+  // A click on a page route: the server answers with build v2's page. The
+  // page moves to v2 once, through moveToLatestBuild, opening the link;
+  // before the fix this was a full load of the old build, on every click.
+  click("toreports");
+  await settle();
+  out.pageRoute = take();
+
+  // A click on a route that renders on the client, whose entry the deploy
+  // removed: the same move, with no page fetch.
+  knownBuild = null;
+  click("toquick");
+  await settle();
+  out.clientRoute = take();
+
+  // The page's last check already saw the new build: the click moves at
+  // once, with no page fetch and no entry load.
+  knownBuild = "v2";
+  click("toreports");
+  await settle();
+  out.knownAhead = take();
+
+  // Offline: the entry cannot load and the server cannot be asked. The
+  // page keeps its screen; no full load, which would show a kept page.
+  moveResult = "offline";
+  knownBuild = null;
+  serverBuild = null as any;
+  click("toquick");
+  await settle();
+  out.offline = take();
+
+  // A page that already moved and is still on the old build: one full
+  // load, and no loop of moves.
+  moveResult = "blocked";
+  serverBuild = "v2";
+  knownBuild = null;
+  click("toreports");
+  await settle();
+  out.blocked = take();
+  return out;
+}
+
+/** The page of build v1 got build v0's manifest. Before the fix it loaded
+ *  v0's route files (gone, so every click was a full page load). */
+async function staleManifest() {
+  const warnings: string[] = [];
+  const warn = console.warn;
+  console.warn = (...args: any[]) => warnings.push(args.map(String).join(" "));
+  try {
+    await setUp();
+    // The server and the page agree on v1; the page's own worker waits
+    // behind the old one, so the updater moves.
+    knownBuild = null;
+    moveResult = "moving";
+    serverBuild = "v1";
+    (globalThis as any).__moveToLatestBuild = async (options: any) => {
+      moves.push(options);
+      return options.recheck ? "moving" : "offline";
+    };
+    click("toreports");
+    await settle();
+    return {
+      moves: moves.splice(0),
+      fullLoads: fullLoads.splice(0),
+      preloads: preloads(),
+      pageFetches: pageFetches(),
+      warnedAboutManifest: warnings.some((w) => w.includes("build manifest is for build v0")),
+    };
+  } finally {
+    console.warn = warn;
+  }
+}
+
+async function defaultFlow() {
   await setUp();
   report.hydrated = observe();
   click("tofast");
@@ -266,6 +420,12 @@ try {
   await traverse("forward");
   report.forward2 = observe();
   report.prefetch = await prefetchTiming();
+  report.deploy = await afterDeploy();
+}
+
+try {
+  if (MODE === "stale-manifest") report.staleManifest = await staleManifest();
+  else await defaultFlow();
 } finally {
   if (dir) fs.rmSync(dir, { recursive: true, force: true });
 }

package/src/ssr-client-nav-runtime.test.ts

@@ -6,15 +6,22 @@
 //     route) render with no page fetch;
 //   - /slow fetches its page, as before;
 //   - back and forward add no history entries and fetch only /slow;
-//   - every navigation resets the scroll, like a fetched one.
+//   - every navigation resets the scroll, like a fetched one;
+//   - after a deploy, a click moves the page to the new build once instead
+//     of a full page load of the old build per click, and an offline page
+//     keeps its screen;
+//   - a build manifest of another build (an older service worker's cached
+//     copy) is not used.
 
 import { beforeAll, describe, expect, test } from "bun:test";
 import path from "node:path";
 
 let report: Record<string, any> = {};
 
-beforeAll(async () => {
-  const proc = Bun.spawn([process.execPath, path.join(import.meta.dir, "ssr-client-nav-runtime.fixture.ts")], {
+async function runFixture(mode?: string): Promise<Record<string, any>> {
+  const args = [process.execPath, path.join(import.meta.dir, "ssr-client-nav-runtime.fixture.ts")];
+  if (mode) args.push(mode);
+  const proc = Bun.spawn(args, {
     cwd: path.join(import.meta.dir, ".."),
     stdout: "pipe",
     stderr: "pipe",
@@ -23,7 +30,12 @@ beforeAll(async () => {
   await proc.exited;
   const line = out.split("\n").find((l) => l.startsWith("REPORT "));
   if (!line) throw new Error(`fixture printed no report:\n${out}\n${err}`);
-  report = JSON.parse(line.slice("REPORT ".length));
+  return JSON.parse(line.slice("REPORT ".length));
+}
+
+beforeAll(async () => {
+  const [main, stale] = await Promise.all([runFixture(), runFixture("stale-manifest")]);
+  report = { ...main, staleManifest: stale.staleManifest };
 }, 60_000);
 
 describe("instant client navigation", () => {
@@ -77,3 +89,55 @@ describe("instant client navigation", () => {
     expect(intent).toBeGreaterThan(0);
   });
 });
+
+describe("a deploy while the page is open", () => {
+  const early = (url: string) => ({ url, skipIfPendingWrites: true });
+  const recheck = (url: string) => ({ url, recheck: true });
+
+  test("before the deploy, an entry that fails to load still gets one full page load", () => {
+    const { sameBuildFailure } = report.deploy;
+    expect(sameBuildFailure.moves).toEqual([early("/reports"), recheck("/reports")]);
+    expect(sameBuildFailure.fullLoads).toEqual(["/reports"]);
+  });
+
+  test("a page route served by the new build moves the page once, with no full load", () => {
+    const { pageRoute } = report.deploy;
+    expect(pageRoute.pageFetches).toEqual(["/reports"]);
+    expect(pageRoute.moves).toEqual([early("/reports"), recheck("/reports")]);
+    expect(pageRoute.fullLoads).toEqual([]);
+  });
+
+  test("a client route whose entry the deploy removed moves the page, with no page fetch", () => {
+    const { clientRoute } = report.deploy;
+    expect(clientRoute.moves).toEqual([early("/quick"), recheck("/quick")]);
+    expect(clientRoute.pageFetches).toEqual([]);
+    expect(clientRoute.fullLoads).toEqual([]);
+  });
+
+  test("when the last check saw the new build, the click moves at once", () => {
+    const { knownAhead } = report.deploy;
+    expect(knownAhead.moves).toEqual([early("/reports")]);
+    expect(knownAhead.pageFetches).toEqual([]);
+    expect(knownAhead.fullLoads).toEqual([]);
+  });
+
+  test("offline, a route that cannot load keeps the current screen", () => {
+    const { offline } = report.deploy;
+    expect(offline.fullLoads).toEqual([]);
+    expect(offline.heading).toBe("slow /slow");
+  });
+
+  test("a page that already moved and is still on the old build gets one full load, not a loop", () => {
+    const { blocked } = report.deploy;
+    expect(blocked.moves).toEqual([early("/reports"), recheck("/reports")]);
+    expect(blocked.fullLoads).toEqual(["/reports"]);
+  });
+
+  test("another build's manifest is not used: no route files of that build load", () => {
+    const stale = report.staleManifest;
+    expect(stale.warnedAboutManifest).toBe(true);
+    expect(stale.preloads.filter((h: string) => h.includes("-v0"))).toEqual([]);
+    expect(stale.moves).toEqual([early("/reports"), recheck("/reports")]);
+    expect(stale.fullLoads).toEqual([]);
+  });
+});