@uniflowed/vite 0.0.0-alpha.35 → 0.0.0-alpha.39

package/driver.js

@@ -42,6 +42,7 @@
 import { randomUUID } from "node:crypto";
 import { createServer as createHttpServer } from "node:http";
 import { builtinModules, register } from "node:module";
+import { installFlowHooks } from "@uniflowed/host/internal/sync-hooks.js";
 import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -54,22 +55,29 @@ import {
 } from "./internal/worker-builtins.js";
 import { emit, errorEvent, eventLogger } from "./internal/events.js";
 import { loadUfConfig, projectConfig } from "./internal/config.js";
-import { send, toRequest } from "./internal/http.js";
+import { send, toAddressRequest, toRequest } from "./internal/http.js";
 import { createOpenApiDocument } from "./internal/openapi.js";
 import { withProjectConfig } from "./merge.js";
 import { FLIGHT_VIRTUAL, RSC_ENVIRONMENT } from "./internal/flight.js";
-import { VIRTUAL, resolveRouteTarget, scanRoutes } from "./internal/routes.js";
+import { MODULE_GRAPH_FILE, createModuleGraphCollector } from "./internal/module-graph.js";
+import { VIRTUAL, resolveRouteTarget, routingRulesOf, scanRoutes } from "./internal/routes.js";
 import {
   BUILD_ID_FILE,
   DOCUMENT_ASSETS_FILE,
+  REGENERATED_DIRECTORY,
+  REGENERATION_FILE,
+  answerRouting,
+  answersInFrontOfFiles,
   assetsFromManifest,
   buildIdentity,
   createPrerenderGate,
   createServeHandler,
   documentAssetsFor,
+  forViteBase,
   loadBuild,
   nodeListener,
   providerSpecifier,
+  readRegeneration,
   withRequest,
 } from "./internal/serve.js";
 
@@ -102,11 +110,23 @@ process.env.UF_PROJECT_ROOT = root;
 // hooks for that; Bun is started with `--preload` on the same package's
 // preload instead, and has no `register`.
 //
+// Deno has no `register` either, and it gets its hooks *here* rather than from
+// a preload, for a reason that is about order. While a Deno `load` hook is
+// registered, `require()` of a native addon fails — and Vite requires one,
+// Rolldown's binding. The static imports above have already loaded Vite by
+// this line, binding included, so hooks installed now see only what is
+// imported after them: the config, and the `@uniflowed/*` modules this driver
+// reaches dynamically. They are the in-thread hooks a new enough Node takes
+// through `@uniflowed/host/register` too; see
+// `@uniflowed/host/internal/sync-hooks.js`.
+//
 // The hooks live in `@uniflowed/host` rather than here: they are how Flow runs
 // on a Capability JS Host, and nothing in them is Vite's. `uf test` reaches for
 // the same package, which is what stopped a test run from depending on a
 // bundler it never loads.
-if (typeof Bun === "undefined" && typeof Deno === "undefined") {
+if (typeof Deno !== "undefined") {
+  installFlowHooks(root);
+} else if (typeof Bun === "undefined") {
   register("@uniflowed/host/internal/node-hooks.js", import.meta.url, { data: { root } });
 }
 
@@ -160,6 +180,15 @@ async function loadConfig() {
   return config;
 }
 
+/**
+ * `app.router.basePath` as the driver uses it: `""` at the root, `"/docs"`
+ * otherwise. Read where the build writes asset URLs and file names, because a
+ * prerendered document is written outside Vite's HTML transform.
+ */
+function basePathOf(config) {
+  return routingRulesOf(config.app?.router).basePath;
+}
+
 /** The Vite inline config a uf config describes. */
 async function viteConfig(config, mode) {
   const { default: uniflowed } = await import("./index.js");
@@ -199,6 +228,27 @@ async function viteConfig(config, mode) {
     configFile: false,
     envDir: false,
     mode,
+    // Vite's dependency cache, kept in the project whatever is above it.
+    // Vite's own default is the nearest `package.json`'s `node_modules/.vite`,
+    // and a uf project needs no `package.json`. One inside another repository
+    // pre-bundled into that repository's `node_modules`, in one directory
+    // shared with every other such project there and emptied by each dev
+    // server that started — which is how two `uf dev` servers came to answer
+    // each other's pre-bundled files with `504 Outdated Optimize Dep`
+    // (ubugeeei-prod/uf#1141).
+    //
+    // This directory rather than `.vite` or `.uf/cache/vite`, because it is
+    // where Vite already puts the cache for a project with its own
+    // `package.json`, so nothing moves for one: the URLs stay
+    // `/node_modules/.vite/deps/…`, and the files stay under `node_modules`,
+    // which git ignores, Vite's watcher skips and Vite's sourcemap ignore list
+    // treats as somebody else's code. `cacheDir` is shared config, so every
+    // environment's optimizer follows it — `deps`, `deps_ssr`, `deps_rsc` —
+    // and a project's own `vite.cacheDir` is merged over it like any option.
+    cacheDir: path.join(root, "node_modules", ".vite"),
+    // `app.router.basePath`: where Vite serves the modules in development, and
+    // what it puts in front of every asset URL a build writes.
+    base: basePathOf(config) === "" ? "/" : `${basePathOf(config)}/`,
     clearScreen: false,
     customLogger: eventLogger(argument("--log-level") ?? "info"),
     plugins: [uniflowed({ root, config, target: routeTarget })],
@@ -445,6 +495,26 @@ async function preview() {
   const draftFirst = {
     name: "uf:draft-before-files",
     configurePreviewServer(previewServer) {
+      // `app.router.headers` and `redirects`, first of all: a redirect answers
+      // before a file is looked for, and a header is pinned on the response so
+      // it survives the `writeHead` Vite's file middleware writes its own
+      // with. `uf start` and every adapter put the same two in front of their
+      // static half; the application's own answers get them from
+      // `createServeHandler` behind. See `internal/serve.js`'s `answerRouting`.
+      const routing = build?.entry?.routing;
+      if (answersInFrontOfFiles(routing)) {
+        previewServer.middlewares.use((request, response, next) => {
+          answerRouting(routing, toAddressRequest(request), response)
+            .then((answered) => {
+              if (answered) return;
+              // The bare base path is the root, which Vite only knows as
+              // `/docs/`; see `forViteBase`.
+              forViteBase(routing, request);
+              next();
+            })
+            .catch(next);
+        });
+      }
       // A prerendered payload is a file whose extension Vite's static middleware
       // knows no type for, and the router hands bytes to React only when they
       // are answered as a payload — so a navigation on a preview would silently
@@ -613,6 +683,18 @@ async function build() {
   //    First, because it is what finds the client modules the next pass has
   //    to build; `./internal/flight.js` has the order and the reason for it.
   const flight = flightStateOf(inline);
+  // `uf build --analyze`: the graph every bundle below is built from, for uf
+  // to attribute to routes; see `./internal/module-graph.js`. A client module
+  // is an entry the browser loads because a server component names it, not on
+  // every page, so it is not one of the client bundle's shared entries.
+  const graph = flag("--analyze")
+    ? createModuleGraphCollector(root, {
+        isReference: (file) => flight?.clientModules.has(file) ?? false,
+      })
+    : null;
+  if (graph != null) {
+    inline.plugins = [...(inline.plugins ?? []), graph.plugin];
+  }
   const rscDir = path.join(root, ".uf", "build", "rsc");
   if (flight != null) {
     emit("phase", { name: "rsc" });
@@ -640,7 +722,7 @@ async function build() {
   });
   const manifest = readManifest(outDir);
   if (flight != null) {
-    recordClientChunks(flight, manifest, references, rscDir);
+    recordClientChunks(flight, manifest, references, rscDir, basePathOf(config));
     // What the summary's "pages in the client bundle" reads. None: a browser
     // that hydrates a payload imports no page, whichever route it is on.
     emit("rsc-split", {
@@ -677,6 +759,9 @@ async function build() {
   // `internal/serve.js`'s `buildIdentity`, which is what reads this.
   writeFileSync(path.join(serverDir, BUILD_ID_FILE), `${mintBuildId()}\n`);
 
+  // Every bundle is built by here, and the prerender below builds none.
+  graph?.write(path.join(root, ".uf", "build", "meta", MODULE_GRAPH_FILE));
+
   // 3. Which routes this build renders when, and every route it renders now.
   //
   //    The decision comes from `uf.config.js` and is made in Rust — see
@@ -687,8 +772,8 @@ async function build() {
   const server = await import(pathToFileURL(path.join(serverDir, "server.js")).href);
   const assets =
     flight == null
-      ? assetsFromManifest(manifest)
-      : flightAssets(manifest, references, rscDir, outDir);
+      ? assetsFromManifest(manifest, basePathOf(config))
+      : flightAssets(manifest, references, rscDir, outDir, basePathOf(config));
   // Recorded beside the server bundle, because whatever serves this build
   // later cannot recompute them from the client manifest alone; see
   // `documentAssetsFor`.
@@ -743,33 +828,86 @@ async function build() {
     failures.push(url);
     emit("page-failed", { url, ...errorEvent(error) });
   };
+  //
+  // Each prerender runs inside a fill that stores nothing, so what a page states
+  // with `cacheLife`, `cacheTag` and `noStore` is something this loop can read
+  // rather than a call that throws for want of a scope.
+  //
+  // A page is written for regeneration when `uf` passed `--regenerate` — `isr`
+  // allowed in `app.rendering.modes`, `rendering.cache.route` on, and a server
+  // deployed to regenerate it — and the page stated a lifetime, called no
+  // `noStore`, and answered 200. Its document goes under
+  // `REGENERATED_DIRECTORY` rather than at its own URL, so no static half
+  // answers the page: the server does, starting from this document, until the
+  // lifetime has passed. What it stated goes into `REGENERATION_FILE` beside the
+  // server bundle. Every other page is the document it has always been.
+  //
+  // A tag without a lifetime is not enough, for the route cache's own reason:
+  // an entry with no end is one another process could serve from its memory
+  // for ever after `revalidateTag` took it out of the shared store.
+  const { collectCacheDeclarations } = await import("@uniflowed/server/cache");
+  const regenerate = flag("--regenerate");
+  const regenerated = {};
   for (const url of pages) {
-    let result;
+    let declared;
+    const renderedAt = Date.now();
     try {
-      result = await server.prerender(url, assets);
+      declared = await collectCacheDeclarations(() => server.prerender(url, assets));
     } catch (error) {
       failed(url, error);
       continue;
     }
+    const result = declared.value;
     if (result.error != null) {
       failed(url, result.error);
       continue;
     }
-    const file = htmlPathFor(outDir, url);
+    const lifetime = declared.lifetime;
+    const regenerates =
+      regenerate && result.status === 200 && declared.denied == null && lifetime != null;
+    // The trailing-slash policy decides a served page's file name; a page the
+    // build regenerates keeps the one layout the regeneration reads.
+    const file = regenerates
+      ? htmlPathFor(path.join(outDir, REGENERATED_DIRECTORY), url)
+      : htmlPathFor(outDir, url, routingRulesOf(config.app?.router).trailingSlash);
     mkdirSync(path.dirname(file), { recursive: true });
     writeFileSync(file, result.html);
     // The payload the document was rendered from, beside it: what a browser
-    // navigating to this route fetches, from whatever serves the files.
+    // navigating to this route fetches, from whatever serves the files. Beside
+    // the document wherever the document went, so a page written for
+    // regeneration leaves no file at its route's own payload URL answering with
+    // the build's copy for ever; the server answers that URL instead.
     if (result.payload != null) {
-      writeFileSync(path.join(path.dirname(file), "__uf.flight"), result.payload);
+      // Beside the route's directory whatever the document is called:
+      // `guide/index.html` and `guide.html` both put it at `guide/__uf.flight`.
+      const payloadDirectory =
+        path.basename(file) === "index.html" ? path.dirname(file) : file.slice(0, -".html".length);
+      mkdirSync(payloadDirectory, { recursive: true });
+      writeFileSync(path.join(payloadDirectory, "__uf.flight"), result.payload);
+    }
+    if (regenerates) {
+      regenerated[url] = {
+        document: regeneratedDocumentUrl(url),
+        renderedAt,
+        revalidate: lifetime.revalidate,
+        expire: lifetime.expire ?? null,
+        tags: declared.tags,
+      };
     }
     emit("page", {
       url,
       file: path.relative(root, file),
       status: result.status,
       bytes: Buffer.byteLength(result.html),
+      regenerates,
     });
   }
+  if (Object.keys(regenerated).length > 0) {
+    writeFileSync(
+      path.join(serverDir, REGENERATION_FILE),
+      `${JSON.stringify({ pages: regenerated }, null, 2)}\n`,
+    );
+  }
   // One `404.html`, from the boundary at the router root: a static host serves
   // a single error document for the whole site, so the nested boundaries a
   // project declares are the server's and the client's to render, not
@@ -1150,13 +1288,21 @@ async function compile() {
  * `static` is deliberately absent; `uf_config`'s
  * `DeployAdapter::is_implemented` is the other half of that fact and
  * `docs/app/reference/cli/$page.mdx` says why.
+ *
+ * `regenerationStore` is where a target keeps the pages a build regenerates
+ * when `rendering.cache.store` names nothing: a disk for a process with one,
+ * Workers KV for a Worker, and `null` for a Lambda, which keeps nothing between
+ * invocations and is refused by name instead. A regenerated page kept only in
+ * memory would go back to the build's copy on every restart, which is a page
+ * that travels back in time. See [`deploy`].
  */
 const ADAPTERS = {
   node: {
-    entries: (document, cache, build, schedules) => ({
-      handler: handlerEntrySource(document, cache, NODE_CAPABILITIES, build),
+    entries: (document, cache, build, schedules, regeneration) => ({
+      handler: handlerEntrySource(document, cache, NODE_CAPABILITIES, build, regeneration),
       server: nodeEntrySource("./handler.js", schedules),
     }),
+    regenerationStore: "filesystem",
   },
   // The same two files as `node`, with `@uniflowed/server/bun` in place of
   // `@uniflowed/server/node`. That module is `./internal/static.js` for every
@@ -1173,32 +1319,40 @@ const ADAPTERS = {
   // nobody here. `edge` pays that price because it must: there is no
   // `node:stream` in a Worker.
   bun: {
-    entries: (document, cache, build, schedules) => ({
-      handler: handlerEntrySource(document, cache, BUN_CAPABILITIES, build),
+    entries: (document, cache, build, schedules, regeneration) => ({
+      handler: handlerEntrySource(document, cache, BUN_CAPABILITIES, build, regeneration),
       server: bunEntrySource("./handler.js", schedules),
     }),
+    regenerationStore: "filesystem",
   },
   deno: {
-    entries: (document, cache, build, schedules) => ({
-      handler: handlerEntrySource(document, cache, DENO_CAPABILITIES, build),
+    entries: (document, cache, build, schedules, regeneration) => ({
+      handler: handlerEntrySource(document, cache, DENO_CAPABILITIES, build, regeneration),
       server: denoEntrySource("./handler.js", schedules),
     }),
+    regenerationStore: "filesystem",
   },
   // The same two files. What `--adapter container` adds is a `Dockerfile` and
   // a `.dockerignore`, and both are plain text that `uf` writes beside this
   // output rather than anything the bundler produces — see `uf_cli`'s
   // `commands::deploy`.
   container: {
-    entries: (document, cache, build, schedules) => ({
-      handler: handlerEntrySource(document, cache, NODE_CAPABILITIES, build),
+    entries: (document, cache, build, schedules, regeneration) => ({
+      handler: handlerEntrySource(document, cache, NODE_CAPABILITIES, build, regeneration),
       server: nodeEntrySource("./handler.js", schedules),
     }),
+    regenerationStore: "filesystem",
   },
   edge: {
-    entries: (document, cache, build, schedules) => ({
-      handler: handlerEntrySource(document, cache, EDGE_CAPABILITIES, build),
+    entries: (document, cache, build, schedules, regeneration) => ({
+      handler: handlerEntrySource(document, cache, EDGE_CAPABILITIES, build, regeneration),
       worker: workerEntrySource("./handler.js", schedules),
     }),
+    // Workers KV, through the same module seam a project's own provider goes
+    // through. `packages/server/cache-kv.js` argues KV over the Cache API: the
+    // seam has to find every entry under a tag, and the Cache API cannot list
+    // what it holds.
+    regenerationStore: "@uniflowed/server/cache/kv",
     // `workerd` first, so React resolves to the build that has
     // `renderToReadableStream` and no `node:stream`. `browser` and `module`
     // after it are Vite's own SSR defaults, kept so a dependency with no
@@ -1215,10 +1369,14 @@ const ADAPTERS = {
     workerBuiltins: true,
   },
   serverless: {
-    entries: (document, cache, build) => ({
-      handler: handlerEntrySource(document, cache, SERVERLESS_CAPABILITIES, build),
+    entries: (document, cache, build, _schedules, regeneration) => ({
+      handler: handlerEntrySource(document, cache, SERVERLESS_CAPABILITIES, build, regeneration),
       lambda: lambdaEntrySource("./handler.js"),
     }),
+    // A Lambda's memory lasts one instance and its disk is that instance's
+    // `/tmp`, so neither is somewhere a regenerated page survives. A build that
+    // regenerates pages has to name a provider module; see [`deploy`].
+    regenerationStore: null,
   },
 };
 
@@ -1349,8 +1507,8 @@ async function deploy() {
   // `randomUUID()` here would key the adapter's copy differently from the one
   // `uf start` serves out of `.uf/build/`, which is two caches for one build.
   const buildId = await buildIdentity(root, path.join(".uf", "build", "server"));
-  const cacheConfig = config.app?.rendering?.cache;
-  if (shape.filesystem === false && cacheConfig?.store === "filesystem") {
+  const declaredCache = config.app?.rendering?.cache;
+  if (shape.filesystem === false && declaredCache?.store === "filesystem") {
     throw new Error(
       `uf: rendering.cache.store is "filesystem" and \`--adapter ${adapter}\` has no ` +
         "filesystem. Name a module exporting `createCacheProvider` instead — a KV " +
@@ -1358,7 +1516,28 @@ async function deploy() {
         "docs/app/guide/cache.",
     );
   }
-  const entries = shape.entries(document, cacheConfig, buildId, schedules);
+  // The pages this build regenerates, and where this target keeps what it
+  // regenerates when the project named no store: the adapter's
+  // `regenerationStore`. A target with nowhere refuses by name and lists the
+  // pages, rather than deploying pages that every cold start takes back to the
+  // build's copy.
+  const regeneration = await readRegeneration(path.join(root, ".uf", "build", "server"));
+  let cacheConfig = declaredCache;
+  if (regeneration != null && declaredCache?.store == null) {
+    if (shape.regenerationStore == null) {
+      const pages = Object.keys(regeneration.pages);
+      throw new Error(
+        `uf: this build regenerates ${pages.length} ${plural(pages.length, "page")} ` +
+          `(${pages.join(", ")}), and \`--adapter ${adapter}\` has nowhere of its own to keep ` +
+          "a regenerated page: an instance's memory and its /tmp both go with the instance. " +
+          "Name a module exporting `createCacheProvider` in rendering.cache.store, or leave " +
+          "`isr` out of app.rendering.modes to prerender those pages as documents that do not " +
+          "change. See docs/app/guide/rendering.",
+      );
+    }
+    cacheConfig = { ...declaredCache, store: shape.regenerationStore };
+  }
+  const entries = shape.entries(document, cacheConfig, buildId, schedules, regeneration);
   const input = {};
   for (const name of Object.keys(entries)) {
     writeFileSync(path.join(work, `${name}.js`), entries[name]);
@@ -1495,7 +1674,7 @@ async function deploy() {
  * `buildIdentity` is where it came from and
  * `packages/server/internal/cache-key.js` is why it exists.
  */
-function handlerEntrySource(document, cache, capabilities, build) {
+function handlerEntrySource(document, cache, capabilities, build, regeneration) {
   const route = cache?.route === true;
   const fetchCache = cache?.fetch === true;
   // Nothing at all when both switches are off, so a default project's
@@ -1509,6 +1688,10 @@ function handlerEntrySource(document, cache, capabilities, build) {
     `document: ${JSON.stringify(document)}`,
     ...(store ? ["cache"] : []),
     "capabilities",
+    // The pages this build regenerates, baked in beside the document and for
+    // the same reason: the manifest exists on the machine doing the build, and
+    // the deployed directory has only what this file carries.
+    ...(store && regeneration != null ? [`regeneration: ${JSON.stringify(regeneration)}`] : []),
   ].join(", ");
   const cacheImport = store ? 'import { createCacheStore } from "@uniflowed/server/cache";\n' : "";
   const providerImport = durable == null ? "" : `${durable.import}\n`;
@@ -1547,8 +1730,11 @@ const capabilities = ${capabilities.name}();
 
 export const fetch = createFetchHandler({ ${options} });
 export const beginRequest = app.beginRequest;
+// \`app.router\`'s redirects and headers, for the entry beside this file to put
+// in front of its static half. Rewrites are \`fetch\`'s own.
+export const routing = app.routing;
 
-export default { fetch, beginRequest };
+export default { fetch, beginRequest, routing };
 `;
 }
 
@@ -1656,7 +1842,7 @@ ${cron.imports}
 // \`@uniflowed/server/node\` above, because the request has to be established in
 // the storage the *application* reads, which is the copy bundled into
 // \`handler.js\`. See ubugeeei-prod/uf#389.
-import { beginRequest, fetch } from ${JSON.stringify(handlerSpecifier)};
+import { beginRequest, fetch, routing } from ${JSON.stringify(handlerSpecifier)};
 
 // Resolved from this file and not from the working directory: a process
 // manager, a container entrypoint and a person in a shell each start a server
@@ -1669,7 +1855,7 @@ ${cron.declarations}
 // (ubugeeei-prod/uf#204) and this entry is a module, so it would work; \`.catch\`
 // is the better spelling regardless — a server that cannot take its port should
 // say so and exit non-zero, rather than die as an unhandled rejection.
-serve({ handle: fetch, staticDir, beginRequest${cron.option} }).catch((error) => {
+serve({ handle: fetch, staticDir, beginRequest, routing${cron.option} }).catch((error) => {
   process.stderr.write(\`uf: \${error?.message ?? String(error)}\\n\`);
   process.exit(1);
 });
@@ -1696,7 +1882,7 @@ ${cron.imports}
 // \`@uniflowed/server/bun\` above, because the request has to be established in
 // the storage the *application* reads, which is the copy bundled into
 // \`handler.js\`. See ubugeeei-prod/uf#389.
-import { beginRequest, fetch } from ${JSON.stringify(handlerSpecifier)};
+import { beginRequest, fetch, routing } from ${JSON.stringify(handlerSpecifier)};
 
 // Resolved from this file and not from the working directory: a process
 // manager, a container entrypoint and a person in a shell each start a server
@@ -1705,7 +1891,7 @@ import { beginRequest, fetch } from ${JSON.stringify(handlerSpecifier)};
 // trap in it.
 const staticDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "static");
 ${cron.declarations}
-serve({ handle: fetch, staticDir, beginRequest${cron.option} }).catch((error) => {
+serve({ handle: fetch, staticDir, beginRequest, routing${cron.option} }).catch((error) => {
   process.stderr.write(\`uf: \${error?.message ?? String(error)}\\n\`);
   process.exit(1);
 });
@@ -1743,7 +1929,7 @@ globalThis.Buffer ??= {
 };
 globalThis.setImmediate ??= (callback, ...args) => setTimeout(callback, 0, ...args);
 globalThis.clearImmediate ??= (handle) => clearTimeout(handle);
-const { beginRequest, fetch } = await import(${JSON.stringify(handlerSpecifier)});
+const { beginRequest, fetch, routing } = await import(${JSON.stringify(handlerSpecifier)});
 
 // Resolved from this file and not from the working directory: a process
 // manager and a person in a shell each start a server from wherever they
@@ -1751,7 +1937,7 @@ const { beginRequest, fetch } = await import(${JSON.stringify(handlerSpecifier)}
 // started from inside itself would be a deployment with a trap in it.
 const staticDir = decodeURIComponent(new URL("./static", import.meta.url).pathname);
 ${cron.declarations}
-serve({ handle: fetch, staticDir, beginRequest${cron.option} }).catch((error) => {
+serve({ handle: fetch, staticDir, beginRequest, routing${cron.option} }).catch((error) => {
   console.error(\`uf: \${error?.message ?? String(error)}\`);
   Deno.exit(1);
 });
@@ -1780,13 +1966,13 @@ function workerEntrySource(handlerSpecifier, schedules) {
     return `// Generated by \`uf build --adapter edge\`. Not checked in, not edited.
 import { createWorkerFetch, installWorkerLogger } from "@uniflowed/server/edge";
 
-import { beginRequest, fetch as handle } from ${JSON.stringify(handlerSpecifier)};
+import { beginRequest, fetch as handle, routing } from ${JSON.stringify(handlerSpecifier)};
 
 // After the imports, so a logger the application installed while it loaded is
 // the one that stays; see \`installWorkerLogger\`.
 installWorkerLogger();
 
-export default { fetch: createWorkerFetch({ handle, beginRequest }) };
+export default { fetch: createWorkerFetch({ handle, beginRequest, routing }) };
 `;
   }
 
@@ -1797,7 +1983,7 @@ export default { fetch: createWorkerFetch({ handle, beginRequest }) };
   return `// Generated by \`uf build --adapter edge\`. Not checked in, not edited.
 import { createWorkerFetch, createWorkerScheduled, installWorkerLogger } from "@uniflowed/server/edge";
 
-import { beginRequest, fetch as handle } from ${JSON.stringify(handlerSpecifier)};
+import { beginRequest, fetch as handle, routing } from ${JSON.stringify(handlerSpecifier)};
 
 // After the imports, so a logger the application installed while it loaded is
 // the one that stays; see \`installWorkerLogger\`.
@@ -1808,7 +1994,7 @@ installWorkerLogger();
 const routes = ${JSON.stringify(routes, null, 2)};
 
 export default {
-  fetch: createWorkerFetch({ handle, beginRequest }),
+  fetch: createWorkerFetch({ handle, beginRequest, routing }),
   scheduled: createWorkerScheduled({ handle, beginRequest, routes }),
 };
 `;
@@ -1834,7 +2020,7 @@ import { fileURLToPath } from "node:url";
 
 import { createLambdaHandler } from "@uniflowed/server/lambda";
 
-import { beginRequest, fetch as handle } from ${JSON.stringify(handlerSpecifier)};
+import { beginRequest, fetch as handle, routing } from ${JSON.stringify(handlerSpecifier)};
 
 // Resolved from this file and not from the working directory: Lambda sets the
 // working directory to the task root today and is under no obligation to keep
@@ -1842,7 +2028,7 @@ import { beginRequest, fetch as handle } from ${JSON.stringify(handlerSpecifier)
 // deployment with a trap in it.
 const staticDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "static");
 
-export const handler = createLambdaHandler({ handle, beginRequest, staticDir });
+export const handler = createLambdaHandler({ handle, beginRequest, staticDir, routing });
 `;
 }
 
@@ -2019,7 +2205,7 @@ async function buildRscGraph(vite, inline, state, { outDir, conditions }) {
  * output names its module by path, which only this build's manifest turns
  * into a URL.
  */
-function recordClientChunks(state, manifest, references, rscDir) {
+function recordClientChunks(state, manifest, references, rscDir, base = "") {
   for (const file of references) {
     const key = path.relative(root, file).split(path.sep).join("/");
     const chunk = manifest[key];
@@ -2029,7 +2215,7 @@ function recordClientChunks(state, manifest, references, rscDir) {
           "client component",
       );
     }
-    state.chunkUrls.set(file, `/${chunk.file}`);
+    state.chunkUrls.set(file, `${base}/${chunk.file}`);
   }
   writeFileSync(
     path.join(rscDir, FLIGHT_BUILD_FILE),
@@ -2061,12 +2247,15 @@ function loadFlightBuild(state, rscDir) {
  * The rsc build's emitted files are copied under `dist/` so those URLs resolve,
  * and only its assets: a server bundle's JavaScript is never a deployable file.
  */
-function flightAssets(manifest, references, rscDir, outDir) {
-  const assets = assetsFromManifest(manifest);
+function flightAssets(manifest, references, rscDir, outDir, base = "") {
+  const assets = assetsFromManifest(manifest, base);
   const styles = new Set();
   const rscManifest = path.join(rscDir, ".vite", "manifest.json");
   if (existsSync(rscManifest)) {
-    const rscStyles = assetsFromManifest(JSON.parse(readFileSync(rscManifest, "utf8"))).styles;
+    const rscStyles = assetsFromManifest(
+      JSON.parse(readFileSync(rscManifest, "utf8")),
+      base,
+    ).styles;
     for (const href of rscStyles) styles.add(href);
   }
   const rscAssets = path.join(rscDir, "assets");
@@ -2083,7 +2272,7 @@ function flightAssets(manifest, references, rscDir, outDir) {
     seen.add(key);
     const chunk = manifest[key];
     if (chunk == null) return;
-    for (const css of chunk.css ?? []) styles.add(`/${css}`);
+    for (const css of chunk.css ?? []) styles.add(`${base}/${css}`);
     for (const imported of chunk.imports ?? []) visit(imported);
   };
   for (const file of references) visit(path.relative(root, file).split(path.sep).join("/"));
@@ -2225,6 +2414,21 @@ async function renderingPlan(server, prerender) {
       why: "a middleware guards it, and a middleware runs once per request",
     });
   }
+  // And `app.router`'s three lists, by the source each rule matches: a file
+  // can be neither a redirect nor a rewrite, and a header a file is served
+  // with is the host's to add rather than the file's.
+  for (const [key, what] of [
+    ["redirects", "a redirect"],
+    ["rewrites", "a rewrite"],
+    ["headers", "a response header"],
+  ]) {
+    for (const rule of server.routing?.[key] ?? []) {
+      perRequest.push({
+        path: rule.source,
+        why: `\`app.router.${key}\` names it, and ${what} is answered when a request arrives`,
+      });
+    }
+  }
 
   return { urls, perRequest };
 }
@@ -2246,9 +2450,36 @@ function fillParams(routePath, params) {
     .join("/");
 }
 
-function htmlPathFor(outDir, url) {
-  const pathname = url.split("?")[0].replace(/^\/+/, "");
-  return pathname === ""
-    ? path.join(outDir, "index.html")
+/**
+ * The file a prerendered page is written to.
+ *
+ * `guide/index.html`, which every static host serves at `/guide/` and most at
+ * `/guide`, unless `app.router.trailingSlash` is `"never"` — then `guide.html`,
+ * which the same hosts serve at `/guide` without a redirect to the slash.
+ * Next.js's static export makes the same choice from the same setting.
+ */
+function htmlPathFor(outDir, url, trailingSlash = "ignore") {
+  const pathname = url.split("?")[0].replace(/^\/+/, "").replace(/\/+$/, "");
+  if (pathname === "") return path.join(outDir, "index.html");
+  return trailingSlash === "never"
+    ? path.join(outDir, `${pathname}.html`)
     : path.join(outDir, pathname, "index.html");
 }
+
+/**
+ * The URL path at which a static half answers the document `htmlPathFor`
+ * wrote for `url` under `REGENERATED_DIRECTORY`.
+ *
+ * Ending in a slash, so every host answers it with that directory's
+ * `index.html` in the same way: a Node static half tries `index.html` for such
+ * a path, and a Worker's assets binding serves it without the redirect it
+ * answers `…/index.html` with.
+ */
+function regeneratedDocumentUrl(url) {
+  const pathname = url.split("?")[0].replace(/^\/+/, "").replace(/\/+$/, "");
+  const encoded = pathname
+    .split("/")
+    .map((segment) => encodeURIComponent(segment))
+    .join("/");
+  return pathname === "" ? `/${REGENERATED_DIRECTORY}/` : `/${REGENERATED_DIRECTORY}/${encoded}/`;
+}