@reckona/mreact-router 0.0.66 → 0.0.68

package/src/adapters/cloudflare.ts

@@ -0,0 +1,1286 @@
+import type { BuiltPrerenderedRoute, BuiltServerManifest } from "../build.js";
+import type { ClientRouteManifestEntry } from "../client.js";
+import type { AppRouterResponseHook } from "../render.js";
+import type {
+  GenerateMetadataContext,
+  ManifestDescriptor,
+  RobotsManifest,
+  RouteMetadata,
+  SitemapEntry,
+} from "../types.js";
+import {
+  emitRouterLog,
+  logDurationMs,
+  logError,
+  logNow,
+  requestLogFields,
+  type AppRouterLogger,
+} from "../logger.js";
+import { normalizeRoutePath } from "../route-path.js";
+import type { AppRoute } from "../routes.js";
+import { isNotFoundError } from "../navigation.js";
+import { routeSecurityHeaders } from "../security-headers.js";
+import type { AppRouterPrerenderStore } from "../serve.js";
+import { emitRouterDevtoolsEvent } from "./devtools.js";
+import { escapeHtmlAttribute, escapeHtmlText } from "@reckona/mreact-shared/html-escape";
+
+export interface CloudflareExecutionContext {
+  passThroughOnException(): void;
+  waitUntil(promise: Promise<unknown>): void;
+}
+
+export interface CloudflareAssetLoader<Env = unknown> {
+  fetch?:
+    | ((
+        pathname: string,
+        request: Request,
+        env: Env,
+        context: CloudflareExecutionContext,
+      ) => Response | Promise<Response | undefined> | undefined)
+    | undefined;
+}
+
+export interface CloudflareRenderContext<Env = unknown> {
+  clientManifest: CloudflareClientManifest;
+  context: CloudflareExecutionContext;
+  env: Env;
+  serverManifest: BuiltServerManifest;
+}
+
+export interface CloudflareRequestHandlerOptions<Env = unknown> {
+  assets?: CloudflareAssetLoader<Env> | undefined;
+  clientManifest: CloudflareClientManifest;
+  logger?: AppRouterLogger | undefined;
+  onResponse?: AppRouterResponseHook | undefined;
+  onError?:
+    | ((
+        error: unknown,
+        request: Request,
+        env: Env,
+        context: CloudflareExecutionContext,
+      ) => Response | Promise<Response>)
+    | undefined;
+  render?:
+    | ((request: Request, context: CloudflareRenderContext<Env>) => Response | Promise<Response>)
+    | undefined;
+  serverManifest: BuiltServerManifest;
+}
+
+export interface CloudflareRequestHandler<Env = unknown> {
+  fetch(request: Request, env: Env, context: CloudflareExecutionContext): Promise<Response>;
+}
+
+export interface CloudflareBuiltRouteRenderContext<
+  Env = unknown,
+> extends CloudflareRenderContext<Env> {
+  params: Record<string, readonly string[] | string>;
+  route: AppRoute;
+}
+
+export interface CloudflareRouteModuleLoaderContext<
+  Env = unknown,
+> extends CloudflareBuiltRouteRenderContext<Env> {
+  request: Request;
+}
+
+export interface CloudflareServerRouteContext<
+  Env = unknown,
+> extends CloudflareBuiltRouteRenderContext<Env> {
+  request: Request;
+}
+
+export interface CloudflareRouteModuleComponentProps<
+  Data = unknown,
+  Env = unknown,
+> extends CloudflareBuiltRouteRenderContext<Env> {
+  data: Data;
+  request: Request;
+}
+
+export type CloudflareRouteModuleComponent<Data = unknown, Env = unknown> = (
+  props: CloudflareRouteModuleComponentProps<Data, Env>,
+) => Response | string | PromiseLike<Response | string>;
+
+export interface CloudflareRouteModule<Data = unknown, Env = unknown> {
+  App?: CloudflareRouteModuleComponent<Data, Env> | undefined;
+  default?: CloudflareRouteModuleComponent<Data, Env> | undefined;
+  generateMetadata?:
+    | ((
+        context: GenerateMetadataContext<Data>,
+      ) => RouteMetadata | PromiseLike<RouteMetadata | undefined> | undefined)
+    | undefined;
+  loader?:
+    | ((context: CloudflareRouteModuleLoaderContext<Env>) => Data | PromiseLike<Data>)
+    | undefined;
+  metadata?: RouteMetadata | undefined;
+}
+
+export type CloudflareServerRouteHandler<Env = unknown> = (
+  request: Request,
+  context: CloudflareServerRouteContext<Env>,
+) => unknown | PromiseLike<unknown>;
+
+export interface CloudflareServerRouteModule<Env = unknown> {
+  ALL?: CloudflareServerRouteHandler<Env> | undefined;
+  DELETE?: CloudflareServerRouteHandler<Env> | undefined;
+  default?: CloudflareServerRouteHandler<Env> | undefined;
+  GET?: CloudflareServerRouteHandler<Env> | undefined;
+  HEAD?: CloudflareServerRouteHandler<Env> | undefined;
+  OPTIONS?: CloudflareServerRouteHandler<Env> | undefined;
+  PATCH?: CloudflareServerRouteHandler<Env> | undefined;
+  POST?: CloudflareServerRouteHandler<Env> | undefined;
+  PUT?: CloudflareServerRouteHandler<Env> | undefined;
+}
+
+export interface CloudflareMetadataRouteContext {
+  baseUrl: string;
+  host: string;
+  params: Record<string, readonly string[] | string>;
+  request: Request;
+}
+
+export interface CloudflareMetadataRouteModule {
+  default?: ((context: CloudflareMetadataRouteContext) => unknown | PromiseLike<unknown>) | undefined;
+}
+
+export type CloudflareRouteModuleRegistryEntry<Env = unknown> =
+  | CloudflareRouteModule<unknown, Env>
+  | CloudflareMetadataRouteModule
+  | CloudflareServerRouteModule<Env>;
+
+export type CloudflareRouteModuleRegistry<Env = unknown> = Record<
+  string,
+  | CloudflareRouteModuleRegistryEntry<Env>
+  | (() => CloudflareRouteModuleRegistryEntry<Env> | PromiseLike<CloudflareRouteModuleRegistryEntry<Env>>)
+>;
+
+export interface CloudflareRouteModuleRendererOptions<Env = unknown> {
+  document?:
+    | ((
+        context: CloudflareRouteModuleComponentProps<unknown, Env> & {
+          body: string;
+          modulePreload: string;
+        },
+      ) => Response | string | PromiseLike<Response | string>)
+    | undefined;
+  modules: CloudflareRouteModuleRegistry<Env>;
+}
+
+export type CloudflareRouteModuleGlob<Env = unknown> = Record<
+  string,
+  | CloudflareRouteModuleRegistryEntry<Env>
+  | (() => CloudflareRouteModuleRegistryEntry<Env> | PromiseLike<CloudflareRouteModuleRegistryEntry<Env>>)
+>;
+
+export interface CollectCloudflareRouteModulesOptions {
+  manifest: BuiltServerManifest;
+}
+
+export interface CloudflareBuiltRequestHandlerOptions<Env = unknown> extends Omit<
+  CloudflareRequestHandlerOptions<Env>,
+  "render"
+> {
+  renderRoute?:
+    | ((
+        request: Request,
+        context: CloudflareBuiltRouteRenderContext<Env>,
+      ) => Response | Promise<Response>)
+    | undefined;
+}
+
+export interface CloudflareClientManifest {
+  publicAssets?: readonly string[] | undefined;
+  routes: ClientRouteManifestEntry[];
+}
+
+export interface CloudflareAssetBinding {
+  fetch(request: Request): Response | Promise<Response>;
+}
+
+export interface CloudflareStaticAssetLoaderOptions<Env = unknown> {
+  binding:
+    | CloudflareAssetBinding
+    | ((
+        env: Env,
+      ) => CloudflareAssetBinding | Promise<CloudflareAssetBinding | undefined> | undefined);
+  clientManifest: CloudflareClientManifest;
+  extraPaths?: readonly string[] | undefined;
+  prefix?: string | undefined;
+}
+
+export interface CloudflareCache {
+  delete(request: Request | string): boolean | Promise<boolean>;
+  match(request: Request | string): Response | Promise<Response | undefined> | undefined;
+  put(request: Request | string, response: Response): void | Promise<void>;
+}
+
+export interface CloudflarePrerenderStoreOptions {
+  cache: CloudflareCache;
+  keyOrigin?: string | undefined;
+  keyPrefix?: string | undefined;
+}
+
+const clientPrefix = "/_mreact/client/";
+const defaultPrerenderCacheOrigin = "https://mreact.local";
+const defaultPrerenderCachePrefix = "/_mreact/prerender";
+
+export function createCloudflareRequestHandler<Env = unknown>(
+  options: CloudflareRequestHandlerOptions<Env>,
+): CloudflareRequestHandler<Env> {
+  return {
+    async fetch(request, env, context) {
+      const startedAt = logNow();
+      try {
+        return await handleCloudflareRequest(options, request, env, context);
+      } catch (error) {
+        const logFields = requestLogFields(request, "cloudflare");
+        emitRouterDevtoolsEvent({
+          method: request.method,
+          type: "router:request:error",
+          url: request.url,
+        });
+        emitRouterLog(options.logger, "error", {
+          ...logFields,
+          durationMs: logDurationMs(startedAt),
+          error: logError(error),
+          type: "router:request:error",
+        });
+
+        return await applyCloudflareResponseHook(
+          options.onError === undefined
+            ? new Response("Internal Server Error", {
+                headers: { "content-type": "text/plain; charset=utf-8" },
+                status: 500,
+              })
+            : await options.onError(error, request, env, context),
+          options,
+          request,
+        );
+      }
+    },
+  };
+}
+
+export function createCloudflareBuiltRequestHandler<Env = unknown>(
+  options: CloudflareBuiltRequestHandlerOptions<Env>,
+): CloudflareRequestHandler<Env> {
+  const sortedRoutes = [...options.serverManifest.routes].sort(compareCloudflareRoutes);
+
+  return createCloudflareRequestHandler({
+    ...options,
+    render(request, context) {
+      const matched = matchCloudflareRoute(
+        sortedRoutes,
+        new URL(request.url).pathname,
+      );
+
+      if (matched === undefined || options.renderRoute === undefined) {
+        return new Response("Not Found", { status: 404 });
+      }
+
+      return options.renderRoute(request, {
+        ...context,
+        params: matched.params,
+        route: matched.route,
+      });
+    },
+  });
+}
+
+export function createCloudflareRouteModuleRenderer<Env = unknown>(
+  options: CloudflareRouteModuleRendererOptions<Env>,
+): NonNullable<CloudflareBuiltRequestHandlerOptions<Env>["renderRoute"]> {
+  return async (request, context) => {
+    if (context.route.kind !== "server" && isCloudflareNavigationRequest(request)) {
+      return cloudflareDocumentReloadNavigationResponse();
+    }
+
+    const module = await loadCloudflareRouteModule(options.modules, context.route.file);
+
+    if (module === undefined) {
+      return new Response(`No Cloudflare route module registered for ${context.route.file}.`, {
+        headers: { "content-type": "text/plain; charset=utf-8" },
+        status: 500,
+      });
+    }
+
+    if (context.route.kind === "server") {
+      return withDefaultSecurityHeaders(
+        await dispatchCloudflareServerRoute(module as CloudflareServerRouteModule<Env>, request, {
+          ...context,
+          request,
+        }),
+        request,
+      );
+    }
+
+    if (context.route.kind === "metadata") {
+      return withDefaultSecurityHeaders(
+        await dispatchCloudflareMetadataRoute(module as CloudflareMetadataRouteModule, request, {
+          ...context,
+          request,
+        }),
+        request,
+      );
+    }
+
+    const pageModule = module as CloudflareRouteModule<unknown, Env>;
+    const component = pageModule.default ?? pageModule.App;
+
+    if (component === undefined) {
+      return new Response(`No Cloudflare page component registered for ${context.route.file}.`, {
+        headers: { "content-type": "text/plain; charset=utf-8" },
+        status: 500,
+      });
+    }
+
+    const loaderContext = {
+      ...context,
+      request,
+    };
+    let data: unknown;
+
+    try {
+      data = pageModule.loader === undefined ? undefined : await pageModule.loader(loaderContext);
+    } catch (error) {
+      if (error instanceof Response) {
+        return error;
+      }
+
+      if (isNotFoundError(error)) {
+        return cloudflareNotFoundResponse(request);
+      }
+
+      throw error;
+    }
+    const props = {
+      ...context,
+      data,
+      request,
+    };
+    let rendered: Awaited<ReturnType<typeof component>>;
+
+    try {
+      rendered = await component(props);
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return cloudflareNotFoundResponse(request);
+      }
+
+      throw error;
+    }
+
+    if (rendered instanceof Response) {
+      return withDefaultSecurityHeaders(rendered, request);
+    }
+
+    const modulePreload = cloudflareModulePreloadTag(context.clientManifest, context.route.path);
+    const metadata = await resolveCloudflareRouteMetadata([pageModule], props);
+    const documented =
+      options.document === undefined
+        ? defaultCloudflareDocument(rendered, modulePreload, metadata)
+        : await options.document({
+            ...props,
+            body: rendered,
+            modulePreload,
+          });
+
+    return withDefaultSecurityHeaders(
+      documented instanceof Response
+        ? documented
+        : new Response(documented, {
+            headers: { "content-type": "text/html; charset=utf-8" },
+          }),
+      request,
+    );
+  };
+}
+
+async function dispatchCloudflareServerRoute<Env>(
+  module: CloudflareServerRouteModule<Env>,
+  request: Request,
+  context: CloudflareServerRouteContext<Env>,
+): Promise<Response> {
+  const handler =
+    module[request.method as keyof CloudflareServerRouteModule<Env>] ?? module.ALL ?? module.default;
+
+  if (typeof handler !== "function") {
+    return new Response("Method Not Allowed", { status: 405 });
+  }
+
+  let response: unknown;
+
+  try {
+    response = await handler(request, context);
+  } catch (error) {
+    if (error instanceof Response) {
+      return error;
+    }
+
+    throw error;
+  }
+
+  return response instanceof Response
+    ? response
+    : new Response("Invalid route response", { status: 500 });
+}
+
+async function dispatchCloudflareMetadataRoute(
+  module: CloudflareMetadataRouteModule,
+  request: Request,
+  context: CloudflareBuiltRouteRenderContext & { request: Request },
+): Promise<Response> {
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    return new Response("Method Not Allowed", {
+      headers: { allow: "GET, HEAD" },
+      status: 405,
+    });
+  }
+
+  if (typeof module.default !== "function") {
+    return new Response("Invalid metadata route response", { status: 500 });
+  }
+
+  const url = new URL(request.url);
+  const value = await module.default({
+    baseUrl: url.origin,
+    host: url.host,
+    params: context.params,
+    request,
+  });
+
+  if (value instanceof Response) {
+    return value;
+  }
+
+  if (context.route.kind !== "metadata") {
+    return new Response("Invalid metadata route convention", { status: 500 });
+  }
+
+  if (context.route.convention === "robots") {
+    return new Response(serializeCloudflareRobots(value as RobotsManifest), {
+      headers: {
+        "cache-control": "public, max-age=3600",
+        "content-type": "text/plain; charset=utf-8",
+      },
+    });
+  }
+
+  if (context.route.convention === "sitemap") {
+    return new Response(serializeCloudflareSitemap(value as readonly SitemapEntry[]), {
+      headers: {
+        "cache-control": "no-cache",
+        "content-type": "application/xml; charset=utf-8",
+      },
+    });
+  }
+
+  if (context.route.convention === "manifest") {
+    return new Response(JSON.stringify(value as ManifestDescriptor), {
+      headers: {
+        "cache-control": "public, max-age=3600",
+        "content-type": "application/manifest+json; charset=utf-8",
+      },
+    });
+  }
+
+  if (context.route.convention === "opengraph-image") {
+    const body = value instanceof Uint8Array ? value.slice().buffer : String(value);
+    return new Response(body, {
+      headers: {
+        "cache-control": "public, max-age=3600",
+        "content-type": typeof value === "string" && value.trimStart().startsWith("<svg")
+          ? "image/svg+xml"
+          : "application/octet-stream",
+      },
+    });
+  }
+
+  return new Response("Invalid metadata route convention", { status: 500 });
+}
+
+function isCloudflareNavigationRequest(request: Request): boolean {
+  return request.headers.get("x-mreact-navigation") === "1";
+}
+
+function cloudflareDocumentReloadNavigationResponse(): Response {
+  return new Response(null, {
+    headers: { "x-mreact-navigation": "reload" },
+    status: 204,
+  });
+}
+
+function withDefaultSecurityHeaders(response: Response, request: Request): Response {
+  const headers = new Headers(response.headers);
+
+  for (const [name, value] of Object.entries(routeSecurityHeaders({ request, security: undefined }))) {
+    if (!headers.has(name)) {
+      headers.set(name, value);
+    }
+  }
+
+  return new Response(response.body, {
+    headers,
+    status: response.status,
+    statusText: response.statusText,
+  });
+}
+
+export function collectCloudflareRouteModules<Env = unknown>(
+  glob: CloudflareRouteModuleGlob<Env>,
+  options: CollectCloudflareRouteModulesOptions,
+): CloudflareRouteModuleRegistry<Env> {
+  const requiredRoutes = options.manifest.routes.filter((route) =>
+    cloudflareRouteRequiresModule(route, options.manifest),
+  );
+  const matchedKeys = new Set<string>();
+  const modules: CloudflareRouteModuleRegistry<Env> = {};
+
+  for (const route of requiredRoutes) {
+    const match = Object.entries(glob).find(([key]) =>
+      cloudflareRouteGlobKeyMatchesRoute(key, route.file),
+    );
+
+    if (match === undefined) {
+      throw new Error(`Missing Cloudflare route module for ${route.file}.`);
+    }
+
+    const [key, module] = match;
+    matchedKeys.add(key);
+    modules[route.file] = module;
+  }
+
+  const extraKeys = Object.keys(glob).filter((key) => !matchedKeys.has(key));
+
+  if (extraKeys.length > 0) {
+    throw new Error(`Extra Cloudflare route module entries: ${extraKeys.join(", ")}.`);
+  }
+
+  return modules;
+}
+
+export function createCloudflareStaticAssetLoader<Env = unknown>(
+  options: CloudflareStaticAssetLoaderOptions<Env>,
+): CloudflareAssetLoader<Env> {
+  const prefix = normalizeAssetPrefix(options.prefix ?? clientPrefix);
+  const allowedPaths = cloudflareClientAssetPaths(options.clientManifest, {
+    extraPaths: options.extraPaths,
+    prefix,
+  });
+
+  return {
+    async fetch(pathname, request, env) {
+      if (!allowedPaths.has(pathname)) {
+        return undefined;
+      }
+
+      const binding =
+        typeof options.binding === "function" ? await options.binding(env) : options.binding;
+
+      if (binding === undefined) {
+        return undefined;
+      }
+
+      const assetUrl = new URL(request.url);
+      assetUrl.pathname = pathname;
+      assetUrl.search = "";
+
+      return await binding.fetch(new Request(assetUrl, request));
+    },
+  };
+}
+
+export function cloudflareClientAssetPaths(
+  manifest: CloudflareClientManifest,
+  options: { extraPaths?: readonly string[] | undefined; prefix?: string | undefined } = {},
+): Set<string> {
+  const prefix = normalizeAssetPrefix(options.prefix ?? clientPrefix);
+  const paths = new Set<string>([`${prefix}manifest.json`]);
+
+  for (const route of manifest.routes) {
+    for (const asset of [
+      route.script,
+      route.sourceMap,
+      route.navigationScript,
+      ...(route.imports ?? []),
+    ]) {
+      const path = safeClientAssetPath(prefix, asset);
+
+      if (path !== undefined) {
+        paths.add(path);
+      }
+    }
+  }
+
+  for (const extraPath of options.extraPaths ?? []) {
+    const path = safeClientAssetPath(prefix, extraPath);
+
+    if (path !== undefined) {
+      paths.add(path);
+    }
+  }
+
+  for (const publicAsset of manifest.publicAssets ?? []) {
+    const path = safePublicAssetPath(publicAsset);
+
+    if (path !== undefined) {
+      paths.add(path);
+    }
+  }
+
+  return paths;
+}
+
+function safePublicAssetPath(asset: string): string | undefined {
+  if (!asset.startsWith("/") || asset.startsWith("//") || asset.includes("..")) {
+    return undefined;
+  }
+
+  return asset;
+}
+
+export function createCloudflarePrerenderStore(
+  options: CloudflarePrerenderStoreOptions,
+): AppRouterPrerenderStore {
+  return {
+    async delete(path) {
+      await options.cache.delete(prerenderCacheRequest(options, path));
+    },
+    async get(path) {
+      const response = await options.cache.match(prerenderCacheRequest(options, path));
+
+      if (response === undefined) {
+        return undefined;
+      }
+
+      return (await response.json()) as BuiltPrerenderedRoute;
+    },
+    async set(path, entry) {
+      await options.cache.put(
+        prerenderCacheRequest(options, path),
+        Response.json(entry, {
+          headers: { "cache-control": "no-store" },
+        }),
+      );
+    },
+  };
+}
+
+async function handleCloudflareRequest<Env>(
+  options: CloudflareRequestHandlerOptions<Env>,
+  request: Request,
+  env: Env,
+  context: CloudflareExecutionContext,
+): Promise<Response> {
+  const startedAt = logNow();
+  const logFields = requestLogFields(request, "cloudflare");
+  emitRouterLog(options.logger, "info", {
+    ...logFields,
+    type: "router:request:start",
+  });
+  emitRouterDevtoolsEvent({
+    method: request.method,
+    type: "router:request:start",
+    url: request.url,
+  });
+
+  const url = new URL(request.url);
+
+  if (
+    url.pathname.startsWith(clientPrefix) ||
+    isCloudflarePublicAssetPath(options.clientManifest, url.pathname)
+  ) {
+    const response = await options.assets?.fetch?.(url.pathname, request, env, context);
+    const assetResponse = await applyCloudflareResponseHook(
+      response ?? new Response("Not Found", { status: 404 }),
+      options,
+      request,
+    );
+    emitRouterLog(options.logger, "info", {
+      ...logFields,
+      durationMs: logDurationMs(startedAt),
+      status: assetResponse.status,
+      type: "router:request:end",
+    });
+    return assetResponse;
+  }
+
+  const staticResponse = prerenderedResponse(
+    options.serverManifest.prerenderedRoutes,
+    normalizeRoutePath(url.pathname),
+    request.method,
+    isCloudflareNavigationRequest(request),
+  );
+
+  if (staticResponse !== undefined) {
+    emitRouterDevtoolsEvent({
+      method: request.method,
+      status: staticResponse.status,
+      type: "router:request:end",
+      url: request.url,
+    });
+    emitRouterLog(options.logger, "info", {
+      ...logFields,
+      durationMs: logDurationMs(startedAt),
+      status: staticResponse.status,
+      type: "router:request:end",
+    });
+    return await applyCloudflareResponseHook(staticResponse, options, request);
+  }
+
+  if (options.render === undefined) {
+    const notFoundResponse = await applyCloudflareResponseHook(
+      new Response("Not Found", { status: 404 }),
+      options,
+      request,
+    );
+    emitRouterLog(options.logger, "info", {
+      ...logFields,
+      durationMs: logDurationMs(startedAt),
+      status: notFoundResponse.status,
+      type: "router:request:end",
+    });
+    return notFoundResponse;
+  }
+
+  const renderedResponse = await options.render(request, {
+    clientManifest: options.clientManifest,
+    context,
+    env,
+    serverManifest: options.serverManifest,
+  });
+  const response = await applyCloudflareResponseHook(
+    preserveCloudflareStreamedHtmlResponse(renderedResponse),
+    options,
+    request,
+  );
+  emitRouterDevtoolsEvent({
+    method: request.method,
+    status: response.status,
+    type: "router:request:end",
+    url: request.url,
+  });
+  emitRouterLog(options.logger, "info", {
+    ...logFields,
+    durationMs: logDurationMs(startedAt),
+    status: response.status,
+    type: "router:request:end",
+  });
+
+  return response;
+}
+
+function isCloudflarePublicAssetPath(manifest: CloudflareClientManifest, pathname: string): boolean {
+  return (manifest.publicAssets ?? []).includes(pathname);
+}
+
+async function applyCloudflareResponseHook<Env>(
+  response: Response,
+  options: Pick<CloudflareRequestHandlerOptions<Env>, "onResponse">,
+  request: Request,
+): Promise<Response> {
+  const hooked = await options.onResponse?.(response, { request });
+
+  return hooked instanceof Response ? hooked : response;
+}
+
+function preserveCloudflareStreamedHtmlResponse(response: Response): Response {
+  if (
+    response.headers.get("x-mreact-stream") !== "1" ||
+    !isHtmlContentType(response.headers.get("content-type"))
+  ) {
+    return response;
+  }
+
+  const headers = new Headers(response.headers);
+  const cacheControl = headers.get("cache-control");
+
+  if (!cacheControlHasDirective(cacheControl, "no-transform")) {
+    headers.set(
+      "cache-control",
+      cacheControl === null || cacheControl.trim() === ""
+        ? "no-transform"
+        : `${cacheControl}, no-transform`,
+    );
+  }
+
+  if (headers.get("content-encoding") === null) {
+    headers.set("content-encoding", "identity");
+  }
+
+  return new Response(response.body, {
+    headers,
+    status: response.status,
+    statusText: response.statusText,
+  });
+}
+
+function isHtmlContentType(contentType: string | null): boolean {
+  return contentType?.toLowerCase().split(";", 1)[0]?.trim() === "text/html";
+}
+
+function cacheControlHasDirective(cacheControl: string | null, directive: string): boolean {
+  if (cacheControl === null) {
+    return false;
+  }
+
+  const normalizedDirective = directive.toLowerCase();
+  return cacheControl
+    .split(",")
+    .some((part) => part.trim().toLowerCase() === normalizedDirective);
+}
+
+function prerenderedResponse(
+  prerenderedRoutes: Record<string, BuiltPrerenderedRoute> | undefined,
+  path: string,
+  method: string,
+  isNavigation: boolean,
+): Response | undefined {
+  if (method !== "GET" && method !== "HEAD") {
+    return undefined;
+  }
+
+  const prerendered = prerenderedRoutes?.[path];
+
+  if (prerendered === undefined) {
+    return undefined;
+  }
+
+  if (isNavigation && !prerendered.html.includes("data-mreact-route-id")) {
+    return cloudflareDocumentReloadNavigationResponse();
+  }
+
+  return new Response(method === "HEAD" ? null : prerendered.html, {
+    headers: prerendered.headers,
+    status: prerendered.status,
+  });
+}
+
+function cloudflareRouteRequiresModule(
+  route: AppRoute,
+  manifest: BuiltServerManifest,
+): boolean {
+  return (
+    route.kind === "metadata" ||
+    route.kind === "server" ||
+    (route.kind === "page" &&
+      (route.segments.some((segment) => segment.kind !== "static") ||
+        manifest.prerenderedRoutes?.[route.path] === undefined))
+  );
+}
+
+function cloudflareRouteGlobKeyMatchesRoute(key: string, routeFile: string): boolean {
+  const normalizedKey = normalizeCloudflareRouteModulePath(key);
+  const normalizedRoute = normalizeCloudflareRouteModulePath(routeFile);
+
+  return (
+    normalizedKey === normalizedRoute ||
+    normalizedKey.endsWith(`/${normalizedRoute}`)
+  );
+}
+
+function normalizeCloudflareRouteModulePath(path: string): string {
+  const withoutPrefix = path
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "")
+    .replace(/^\/+/, "");
+
+  return withoutPrefix.replace(/\.(?:mjs|js|ts|tsx)$/, "");
+}
+
+function matchCloudflareRoute(
+  routes: readonly AppRoute[],
+  pathname: string,
+): { params: Record<string, readonly string[] | string>; route: AppRoute } | undefined {
+  const normalizedPath = normalizeRoutePath(pathname);
+  const pathSegments = normalizedPath === "/" ? [] : normalizedPath.slice(1).split("/");
+
+  for (const route of routes) {
+    const params: Record<string, readonly string[] | string> = {};
+    const catchAllIndex = route.segments.findIndex((segment) => segment.kind === "catch-all");
+
+    if (catchAllIndex === -1 && route.segments.length !== pathSegments.length) {
+      continue;
+    }
+
+    if (
+      catchAllIndex !== -1 &&
+      pathSegments.length <
+        catchAllIndex + 1 + route.segments.length - catchAllIndex - 1
+    ) {
+      continue;
+    }
+
+    let matched = true;
+
+    for (const [index, segment] of route.segments.entries()) {
+      const value = pathSegments[index];
+
+      if (value === undefined) {
+        matched = false;
+        break;
+      }
+
+      if (segment.kind === "static") {
+        if (segment.value !== value) {
+          matched = false;
+          break;
+        }
+        continue;
+      }
+
+      if (segment.kind === "dynamic") {
+        const decoded = safeDecodePathSegment(value);
+        if (decoded === undefined) {
+          matched = false;
+          break;
+        }
+        params[segment.name] = decoded;
+        continue;
+      }
+
+      const suffixSegments = route.segments.slice(index + 1);
+      const catchAllEnd = pathSegments.length - suffixSegments.length;
+
+      if (catchAllEnd <= index) {
+        matched = false;
+        break;
+      }
+
+      const decodedParts: string[] = [];
+      for (const part of pathSegments.slice(index, catchAllEnd)) {
+        const decoded = safeDecodePathSegment(part);
+        if (decoded === undefined) {
+          matched = false;
+          break;
+        }
+        decodedParts.push(decoded);
+      }
+      params[segment.name] = decodedParts;
+
+      for (let suffixIndex = 0; suffixIndex < suffixSegments.length; suffixIndex += 1) {
+        const suffixSegment = suffixSegments[suffixIndex];
+        const suffixValue = pathSegments[catchAllEnd + suffixIndex];
+
+        if (suffixSegment === undefined || suffixValue === undefined) {
+          matched = false;
+          break;
+        }
+
+        if (suffixSegment.kind === "static") {
+          if (suffixSegment.value !== suffixValue) {
+            matched = false;
+            break;
+          }
+          continue;
+        }
+
+        if (suffixSegment.kind === "dynamic") {
+          const decoded = safeDecodePathSegment(suffixValue);
+          if (decoded === undefined) {
+            matched = false;
+            break;
+          }
+          params[suffixSegment.name] = decoded;
+          continue;
+        }
+
+        matched = false;
+        break;
+      }
+
+      break;
+    }
+
+    if (matched) {
+      return { params, route };
+    }
+  }
+
+  return undefined;
+}
+
+function compareCloudflareRoutes(a: AppRoute, b: AppRoute): number {
+  const scoreDelta = routeSpecificityScore(b) - routeSpecificityScore(a);
+
+  return scoreDelta === 0 ? a.path.localeCompare(b.path) || a.kind.localeCompare(b.kind) : scoreDelta;
+}
+
+function routeSpecificityScore(route: AppRoute): number {
+  return route.segments.reduce((score, segment) => {
+    if (segment.kind === "static") {
+      return score + 100;
+    }
+
+    if (segment.kind === "dynamic") {
+      return score + 10;
+    }
+
+    return score;
+  }, route.segments.length);
+}
+
+function safeDecodePathSegment(segment: string): string | undefined {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizeAssetPrefix(prefix: string): string {
+  const withLeadingSlash = prefix.startsWith("/") ? prefix : `/${prefix}`;
+
+  return withLeadingSlash.endsWith("/") ? withLeadingSlash : `${withLeadingSlash}/`;
+}
+
+function safeClientAssetPath(prefix: string, asset: string | undefined): string | undefined {
+  if (asset === undefined || asset === "" || asset.startsWith("/") || asset.includes("\\")) {
+    return undefined;
+  }
+
+  const segments = asset.split("/");
+
+  if (segments.some((segment) => unsafeAssetSegment(segment))) {
+    return undefined;
+  }
+
+  return `${prefix}${segments.join("/")}`;
+}
+
+function unsafeAssetSegment(segment: string): boolean {
+  if (segment === "" || segment === "." || segment === "..") {
+    return true;
+  }
+
+  try {
+    const decoded = decodeURIComponent(segment);
+    return decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\");
+  } catch {
+    return true;
+  }
+}
+
+async function loadCloudflareRouteModule<Env>(
+  modules: CloudflareRouteModuleRegistry<Env>,
+  file: string,
+): Promise<CloudflareRouteModuleRegistryEntry<Env> | undefined> {
+  const entry = modules[file];
+
+  return typeof entry === "function" ? await entry() : entry;
+}
+
+function cloudflareModulePreloadTag(manifest: CloudflareClientManifest, routePath: string): string {
+  const script = manifest.routes.find((route) => route.path === routePath)?.script;
+
+  return script === undefined
+    ? ""
+    : `<link rel="modulepreload" href="/_mreact/client/${escapeHtmlAttribute(script)}">`;
+}
+
+async function resolveCloudflareRouteMetadata<Data, Env>(
+  modules: readonly CloudflareRouteModule<Data, Env>[],
+  context: GenerateMetadataContext<Data>,
+): Promise<RouteMetadata | undefined> {
+  const metadata: RouteMetadata[] = [];
+
+  for (const module of modules) {
+    let next = module.metadata;
+
+    if (module.generateMetadata !== undefined) {
+      const generated = await module.generateMetadata(context);
+      next = mergeCloudflareRouteMetadata([next, generated].filter(isCloudflareRouteMetadata));
+    }
+
+    if (next !== undefined) {
+      metadata.push(next);
+    }
+  }
+
+  return mergeCloudflareRouteMetadata(metadata);
+}
+
+function isCloudflareRouteMetadata(value: RouteMetadata | undefined): value is RouteMetadata {
+  return value !== undefined;
+}
+
+function mergeCloudflareRouteMetadata(metadata: readonly RouteMetadata[]): RouteMetadata | undefined {
+  if (metadata.length === 0) {
+    return undefined;
+  }
+
+  return metadata.reduce<RouteMetadata>((merged, next) => {
+    const openGraph = mergeCloudflareMetadataObject(merged.openGraph, next.openGraph);
+    const openGraphImages = mergeCloudflareMetadataArrays(
+      merged.openGraph?.images,
+      next.openGraph?.images,
+    );
+
+    const alternates = mergeCloudflareMetadataObject(merged.alternates, next.alternates);
+    const csp = mergeCloudflareMetadataObject(merged.csp, next.csp);
+    const head = mergeCloudflareMetadataArrays(merged.head, next.head);
+    const icons = mergeCloudflareMetadataObject(merged.icons, next.icons);
+    const mergedMetadata: RouteMetadata = {
+      ...merged,
+      ...next,
+      ...(alternates === undefined ? {} : { alternates }),
+      ...(csp === undefined ? {} : { csp }),
+      ...(head === undefined ? {} : { head }),
+      ...(icons === undefined ? {} : { icons }),
+      ...(openGraph === undefined && openGraphImages === undefined
+        ? {}
+        : { openGraph: { ...openGraph, ...(openGraphImages === undefined ? {} : { images: openGraphImages }) } }),
+    };
+
+    return mergedMetadata;
+  }, {});
+}
+
+function mergeCloudflareMetadataObject<T extends object>(
+  left: T | undefined,
+  right: T | undefined,
+): T | undefined {
+  if (left === undefined) {
+    return right;
+  }
+  if (right === undefined) {
+    return left;
+  }
+
+  return { ...left, ...right };
+}
+
+function mergeCloudflareMetadataArrays<T>(
+  left: readonly T[] | undefined,
+  right: readonly T[] | undefined,
+): readonly T[] | undefined {
+  if (left === undefined || left.length === 0) {
+    return right;
+  }
+  if (right === undefined || right.length === 0) {
+    return left;
+  }
+
+  return [...left, ...right];
+}
+
+function defaultCloudflareDocument(
+  body: string,
+  modulePreload: string,
+  metadata: RouteMetadata | undefined,
+): string {
+  return `<!DOCTYPE html><html><head>${modulePreload}${cloudflareMetadataTitle(metadata)}</head><body>${body}</body></html>`;
+}
+
+function cloudflareMetadataTitle(metadata: RouteMetadata | undefined): string {
+  if (metadata?.title === undefined) {
+    return "";
+  }
+
+  return `<title>${escapeHtmlText(metadataString(metadata.title))}</title>`;
+}
+
+function metadataString(value: boolean | number | string): string {
+  return String(value);
+}
+
+function serializeCloudflareRobots(manifest: RobotsManifest): string {
+  const lines: string[] = [];
+  const rules =
+    manifest.rules === undefined
+      ? []
+      : Array.isArray(manifest.rules)
+        ? manifest.rules
+        : [manifest.rules];
+
+  for (const rule of rules) {
+    for (const userAgent of arrayValue(rule.userAgent)) {
+      lines.push(`User-agent: ${userAgent}`);
+    }
+    for (const allow of arrayValue(rule.allow)) {
+      lines.push(`Allow: ${allow}`);
+    }
+    for (const disallow of arrayValue(rule.disallow)) {
+      lines.push(`Disallow: ${disallow}`);
+    }
+  }
+
+  for (const sitemap of arrayValue(manifest.sitemap)) {
+    lines.push(`Sitemap: ${sitemap}`);
+  }
+  if (manifest.host !== undefined) {
+    lines.push(`Host: ${manifest.host}`);
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+function serializeCloudflareSitemap(entries: readonly SitemapEntry[]): string {
+  const urls = entries
+    .map((entry) => {
+      const fields = [
+        `<loc>${escapeXml(entry.url)}</loc>`,
+        entry.lastModified === undefined
+          ? undefined
+          : `<lastmod>${escapeXml(sitemapDate(entry.lastModified))}</lastmod>`,
+        entry.changeFrequency === undefined
+          ? undefined
+          : `<changefreq>${escapeXml(entry.changeFrequency)}</changefreq>`,
+        entry.priority === undefined ? undefined : `<priority>${entry.priority}</priority>`,
+      ].filter((field): field is string => field !== undefined);
+
+      return `<url>${fields.join("")}</url>`;
+    })
+    .join("");
+
+  return `<?xml version="1.0" encoding="UTF-8"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${urls}</urlset>`;
+}
+
+function sitemapDate(value: Date | number | string): string {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  return typeof value === "number" ? new Date(value).toISOString() : value;
+}
+
+function arrayValue<T>(value: T | readonly T[] | undefined): readonly T[] {
+  if (value === undefined) {
+    return [];
+  }
+
+  return Array.isArray(value) ? (value as readonly T[]) : [value as T];
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+}
+
+function cloudflareNotFoundResponse(request: Request): Response {
+  return withDefaultSecurityHeaders(
+    new Response("<!DOCTYPE html><html><head></head><body>Not Found</body></html>", {
+      headers: { "content-type": "text/html; charset=utf-8" },
+      status: 404,
+    }),
+    request,
+  );
+}
+
+function prerenderCacheRequest(options: CloudflarePrerenderStoreOptions, path: string): Request {
+  const origin = options.keyOrigin ?? defaultPrerenderCacheOrigin;
+  const prefix = options.keyPrefix ?? defaultPrerenderCachePrefix;
+  const normalizedPath = normalizeRoutePath(path.startsWith("/") ? path : `/${path}`);
+  const url = new URL(`${normalizePrerenderPrefix(prefix)}${normalizedPath}`, origin);
+
+  return new Request(url, { method: "GET" });
+}
+
+function normalizePrerenderPrefix(prefix: string): string {
+  const withLeadingSlash = prefix.startsWith("/") ? prefix : `/${prefix}`;
+
+  return withLeadingSlash.replace(/\/+$/, "");
+}