cdk-nextjs 0.6.2 → 0.7.0

package/lib/adapter/cache-utils.d.ts

@@ -5,8 +5,98 @@ import type { SetIncrementalFetchCacheContext, SetIncrementalResponseCacheContex
 export declare function serializeCacheValue(value: any): string;
 /**
  * Parse cache value with custom handling for Map and Buffer objects
+ *
+ * Buffers are read back from base64 when that is how they were written, and from
+ * an array of per-byte integers when they were not. That array is the format
+ * `Buffer.toJSON()` produces and the one this code used to write, and it is
+ * ruinous for a page with a large payload: a 1 MiB prerender became ~3 MiB of
+ * JSON text, an 11.6 MiB cache entry once html and the per-segment copies are
+ * counted, and — because `JSON.parse`'s reviver runs for *every array element* —
+ * upwards of three million reviver calls to read one page. Measured against a
+ * deployment: 4.8s of Lambda time to answer a 1 MiB segment prefetch, against
+ * 45ms for a small one from the same cache. base64 is 4/3 the bytes rather than
+ * ~3x, and `Buffer.from(str, "base64")` is one native call.
  */
 export declare function parseCacheValue(jsonString: string): any;
+/**
+ * The cache key a prerendered route's seeded entry has to be written under.
+ *
+ * `ctx.outputs.prerenders[].pathname` is the *URL* the page is served at, so it
+ * carries the app's `basePath`. The key the server later looks entries up under
+ * is the route, which does not — Next.js strips `basePath` before routing, so the
+ * cache handler never sees it at request time. Seeding `/prod/ssg/1` verbatim
+ * therefore writes `<buildId>/prod/ssg/1.json` while the server asks for
+ * `<buildId>/ssg/1.json`: every build-time prerender is a MISS that re-renders on
+ * first request, and the page is only "static" from the second visit onwards.
+ */
+export declare function prerenderPathToCacheKey(pathname: string, basePath: string): string;
+/** The outputs one route contributes to `ctx.outputs.prerenders`. */
+export interface PrerenderVariants<T> {
+    /** The HTML render. Its pathname is the route, with no suffix. */
+    html?: T;
+    /** The flight payload, built as `<route>.rsc` — but see {@link groupPrerenders}. */
+    rsc?: T;
+    /** Per-segment flight payloads, under `<route>.segments/`. */
+    segments: T[];
+    /** A Pages Router route's `pageData`, built as its `/_next/data/` route. */
+    data?: T;
+}
+/**
+ * Collect `ctx.outputs.prerenders` into one entry per route.
+ *
+ * Next.js emits up to three shapes per prerendered App Router route — `/blog/hello`,
+ * `/blog/hello.rsc`, and `/blog/hello.segments/*.segment.rsc` — and a cache entry
+ * needs all of them together, so they have to be grouped by route before anything
+ * can be seeded. A Pages Router route emits two: the HTML, and its `pageData` at
+ * the route's `/_next/data/<buildId>/<page>.json` pathname
+ * ({@link PAGES_DATA_PATHNAME}). That one is not a suffix of the page's own
+ * pathname, so it is matched rather than stripped.
+ *
+ * The one case that is not a suffix strip is the **root route**, which cannot be
+ * named `/.rsc`: its payloads are emitted under `/index.rsc` and
+ * `/index.segments/` while its HTML stays at `/` (or at the `basePath`, e.g.
+ * `/prod` and `/prod/index.rsc`). Reconstructing names by concatenation therefore
+ * silently loses the home page's `rscData` — and with a `basePath` also its
+ * `segmentData`, because `/prod` and `/prod/index` group apart. That is not a
+ * cosmetic gap: `app-page-runtime.js` answers an RSC request for an entry with no
+ * `rscData` by checking `cachedData.html.contentType`, and under `cacheComponents`
+ * sends an empty `404`. Every client-side navigation to `/` breaks.
+ *
+ * The remap is conditional rather than unconditional so that an app with a real
+ * page at `app/index/page.tsx` — whose HTML prerender genuinely is `/index` — keeps
+ * its own group.
+ */
+export declare function groupPrerenders<T extends {
+    pathname: string;
+}>(prerenders: T[]): Map<string, PrerenderVariants<T>>;
+/** See {@link NON_CACHEABLE_APP_PAGE_HEADERS}. */
+export declare function appPageCacheHeaders<T>(initialHeaders: Record<string, T>): Record<string, T>;
+/**
+ * The tags a cache value's render was tagged with, as Next.js records them: in
+ * its `x-next-cache-tags` header, comma separated, including the implicit
+ * `_N_T_/…` path chain `revalidatePath` uses. One parser for the build's tag
+ * manifest and the runtime's mapping rows, which have to agree.
+ *
+ * `value` is `unknown` because it arrives both as a stored entry read back from
+ * S3 and as the `IncrementalCacheValue` union; only some members have headers.
+ */
+export declare function headerTags(value: unknown): string[];
+/**
+ * Name of the file the adapter writes into the init cache directory mapping each
+ * cache tag to the cache keys of the build-time prerenders carrying it.
+ *
+ * It rides to S3 with the rest of the init cache, and `S3CacheHandler`'s
+ * `revalidateTag` reads it alongside the `tag#cacheKey` rows a runtime `set`
+ * writes. Without it `revalidateTag` knows a prerender is stale (see
+ * `checkIfRevalidated`) but not which CloudFront paths to invalidate, so the CDN
+ * keeps serving the old response until its TTL expires - a year, for a
+ * prerender.
+ *
+ * The leading underscore keeps it clear of cache keys, which are route paths.
+ */
+export declare const INIT_CACHE_TAG_MANIFEST = "_cdk-nextjs-tag-manifest.json";
+/** Contents of {@link INIT_CACHE_TAG_MANIFEST}: tag -> init cache keys. */
+export type InitCacheTagManifest = Record<string, string[]>;
 /**
  * Helper to safely extract tags from context
  */

package/lib/adapter/cache-utils.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INIT_CACHE_TAG_MANIFEST = void 0;
 exports.serializeCacheValue = serializeCacheValue;
 exports.parseCacheValue = parseCacheValue;
+exports.prerenderPathToCacheKey = prerenderPathToCacheKey;
+exports.groupPrerenders = groupPrerenders;
+exports.appPageCacheHeaders = appPageCacheHeaders;
+exports.headerTags = headerTags;
 exports.getTags = getTags;
+const base_path_1 = require("../utils/base-path");
 /**
  * Pre-process value to convert Buffers and Maps before JSON.stringify
  * This is necessary because Buffer.toJSON() is called before replacer functions
@@ -12,11 +18,13 @@ function preprocessValue(value) {
     if (value == null) {
         return value;
     }
-    // Convert Buffer to our custom format
+    // Convert Buffer to our custom format. base64, not the array of per-byte
+    // integers this used to write (and that `Buffer.toJSON()` writes) — see
+    // {@link parseCacheValue} for why that mattered so much.
     if (Buffer.isBuffer(value)) {
         return {
             __type: "Buffer",
-            data: Array.from(value),
+            base64: value.toString("base64"),
         };
     }
     // Convert Map to our custom format
@@ -56,6 +64,17 @@ function serializeCacheValue(value) {
 }
 /**
  * Parse cache value with custom handling for Map and Buffer objects
+ *
+ * Buffers are read back from base64 when that is how they were written, and from
+ * an array of per-byte integers when they were not. That array is the format
+ * `Buffer.toJSON()` produces and the one this code used to write, and it is
+ * ruinous for a page with a large payload: a 1 MiB prerender became ~3 MiB of
+ * JSON text, an 11.6 MiB cache entry once html and the per-segment copies are
+ * counted, and — because `JSON.parse`'s reviver runs for *every array element* —
+ * upwards of three million reviver calls to read one page. Measured against a
+ * deployment: 4.8s of Lambda time to answer a 1 MiB segment prefetch, against
+ * 45ms for a small one from the same cache. base64 is 4/3 the bytes rather than
+ * ~3x, and `Buffer.from(str, "base64")` is one native call.
  */
 function parseCacheValue(jsonString) {
     return JSON.parse(jsonString, (_key, val) => {
@@ -65,7 +84,9 @@ function parseCacheValue(jsonString) {
         }
         // Restore Buffer objects that were serialized with __type marker (our custom format)
         if (val && typeof val === "object" && val.__type === "Buffer") {
-            return Buffer.from(val.data);
+            return typeof val.base64 === "string"
+                ? Buffer.from(val.base64, "base64")
+                : Buffer.from(val.data);
         }
         // Restore Buffer objects that were serialized with Node.js default Buffer.toJSON() format
         // This handles legacy cache entries or runtime-generated entries
@@ -78,10 +99,184 @@ function parseCacheValue(jsonString) {
         return val;
     });
 }
+/**
+ * The cache key a prerendered route's seeded entry has to be written under.
+ *
+ * `ctx.outputs.prerenders[].pathname` is the *URL* the page is served at, so it
+ * carries the app's `basePath`. The key the server later looks entries up under
+ * is the route, which does not — Next.js strips `basePath` before routing, so the
+ * cache handler never sees it at request time. Seeding `/prod/ssg/1` verbatim
+ * therefore writes `<buildId>/prod/ssg/1.json` while the server asks for
+ * `<buildId>/ssg/1.json`: every build-time prerender is a MISS that re-renders on
+ * first request, and the page is only "static" from the second visit onwards.
+ */
+function prerenderPathToCacheKey(pathname, basePath) {
+    // Matching on a path boundary so a sibling route like `/production` is not
+    // read as basePath `/prod` plus `uction`.
+    const route = ((0, base_path_1.hasPathPrefix)(pathname, basePath)
+        ? pathname.slice(basePath.length)
+        : pathname)
+        // Leading slashes would make an S3 key with an empty first segment.
+        .replace(/^\/+/, "");
+    return route === "" ? "index" : route;
+}
+const INDEX_SUFFIX = "/index";
+/**
+ * A Pages Router data route: `/_next/data/<buildId>/<page>.json`, optionally
+ * behind a `basePath` (`normalizePathname` in Next.js's `build-complete` prefixes
+ * every output pathname, this one included).
+ *
+ * Capture 1 is that prefix and capture 2 the page path without its `.json`, so
+ * `/prod/_next/data/abc123/blog/hello.json` recomposes to `/prod/blog/hello`.
+ */
+const PAGES_DATA_PATHNAME = /^(.*)\/_next\/data\/[^/]+\/(.+)\.json$/;
+/**
+ * Collect `ctx.outputs.prerenders` into one entry per route.
+ *
+ * Next.js emits up to three shapes per prerendered App Router route — `/blog/hello`,
+ * `/blog/hello.rsc`, and `/blog/hello.segments/*.segment.rsc` — and a cache entry
+ * needs all of them together, so they have to be grouped by route before anything
+ * can be seeded. A Pages Router route emits two: the HTML, and its `pageData` at
+ * the route's `/_next/data/<buildId>/<page>.json` pathname
+ * ({@link PAGES_DATA_PATHNAME}). That one is not a suffix of the page's own
+ * pathname, so it is matched rather than stripped.
+ *
+ * The one case that is not a suffix strip is the **root route**, which cannot be
+ * named `/.rsc`: its payloads are emitted under `/index.rsc` and
+ * `/index.segments/` while its HTML stays at `/` (or at the `basePath`, e.g.
+ * `/prod` and `/prod/index.rsc`). Reconstructing names by concatenation therefore
+ * silently loses the home page's `rscData` — and with a `basePath` also its
+ * `segmentData`, because `/prod` and `/prod/index` group apart. That is not a
+ * cosmetic gap: `app-page-runtime.js` answers an RSC request for an entry with no
+ * `rscData` by checking `cachedData.html.contentType`, and under `cacheComponents`
+ * sends an empty `404`. Every client-side navigation to `/` breaks.
+ *
+ * The remap is conditional rather than unconditional so that an app with a real
+ * page at `app/index/page.tsx` — whose HTML prerender genuinely is `/index` — keeps
+ * its own group.
+ */
+function groupPrerenders(prerenders) {
+    const htmlPathnames = new Set(prerenders
+        .map((p) => p.pathname)
+        .filter((p) => !p.endsWith(".rsc") &&
+        !p.includes(".segments/") &&
+        !PAGES_DATA_PATHNAME.test(p)));
+    const groups = new Map();
+    const variantsFor = (base) => {
+        let variants = groups.get(base);
+        if (!variants) {
+            variants = { segments: [] };
+            groups.set(base, variants);
+        }
+        return variants;
+    };
+    /** `/index.rsc` belongs to `/`, `/prod/index.rsc` to `/prod`. */
+    const routeOf = (base) => {
+        if (base.endsWith(INDEX_SUFFIX) && !htmlPathnames.has(base)) {
+            const parent = base.slice(0, -INDEX_SUFFIX.length) || "/";
+            if (htmlPathnames.has(parent)) {
+                return parent;
+            }
+        }
+        return base;
+    };
+    for (const prerender of prerenders) {
+        const { pathname } = prerender;
+        const dataRoute = PAGES_DATA_PATHNAME.exec(pathname);
+        if (dataRoute) {
+            variantsFor(routeOf(`${dataRoute[1]}/${dataRoute[2]}`)).data = prerender;
+        }
+        else if (pathname.includes(".segments/")) {
+            variantsFor(routeOf(pathname.split(".segments/")[0])).segments.push(prerender);
+        }
+        else if (pathname.endsWith(".rsc")) {
+            variantsFor(routeOf(pathname.slice(0, -".rsc".length))).rsc = prerender;
+        }
+        else {
+            variantsFor(pathname).html = prerender;
+        }
+    }
+    return groups;
+}
+/**
+ * Headers that must not be seeded into an `APP_PAGE` cache entry, even though the
+ * adapter output lists them in `fallback.initialHeaders`.
+ *
+ * `initialHeaders` describes how a platform should serve the prerendered *file*
+ * straight off a CDN. A cache entry is a different thing: `app-page-runtime.js`
+ * `appendHeader`s `cachedData.headers` onto the response and *then* serves the
+ * variant the request actually asked for, so anything presentational in there is
+ * either wrong or doubled. At request time Next.js stores only what the render
+ * put in `metadata.headers` — `x-nextjs-stale-time`, `x-next-cache-tags`, and
+ * whatever the app set through `headers()`/`cookies()` — and never these four.
+ *
+ * `content-type` is the one that actually breaks. `send-payload.js` sets the type
+ * only when the response does not already have one
+ * (`if (!res.getHeader('Content-Type') && result.contentType)`), so a seeded
+ * `text/html; charset=utf-8` makes every RSC request to a prerendered page answer
+ * the flight payload labeled as HTML. The client router rejects that, and so does
+ * Next.js itself: `createRedirectRenderResult` checks the content type of the
+ * sub-response it fetches to stream an action `redirect()`, and on a mismatch
+ * cancels the body and returns an empty result.
+ *
+ * `vary`, `x-nextjs-prerender`, and `x-nextjs-postponed` are all set by the
+ * entrypoint itself, so seeding them only produces two of each.
+ *
+ * `APP_ROUTE` entries are deliberately *not* filtered: a route handler's
+ * `content-type` is part of its cached response, and `app-route.js` replays those
+ * headers verbatim.
+ */
+const NON_CACHEABLE_APP_PAGE_HEADERS = new Set([
+    "content-type",
+    "vary",
+    "x-nextjs-prerender",
+    "x-nextjs-postponed",
+]);
+/** See {@link NON_CACHEABLE_APP_PAGE_HEADERS}. */
+function appPageCacheHeaders(initialHeaders) {
+    const headers = {};
+    for (const [name, value] of Object.entries(initialHeaders)) {
+        if (!NON_CACHEABLE_APP_PAGE_HEADERS.has(name.toLowerCase())) {
+            headers[name] = value;
+        }
+    }
+    return headers;
+}
+/** `NEXT_CACHE_TAGS_HEADER`, inlined so this file imports no Next.js internals. */
+const NEXT_CACHE_TAGS_HEADER = "x-next-cache-tags";
+/**
+ * The tags a cache value's render was tagged with, as Next.js records them: in
+ * its `x-next-cache-tags` header, comma separated, including the implicit
+ * `_N_T_/…` path chain `revalidatePath` uses. One parser for the build's tag
+ * manifest and the runtime's mapping rows, which have to agree.
+ *
+ * `value` is `unknown` because it arrives both as a stored entry read back from
+ * S3 and as the `IncrementalCacheValue` union; only some members have headers.
+ */
+function headerTags(value) {
+    const headers = value
+        ?.headers;
+    const header = headers?.[NEXT_CACHE_TAGS_HEADER];
+    return typeof header === "string" ? header.split(",").filter(Boolean) : [];
+}
+/**
+ * Name of the file the adapter writes into the init cache directory mapping each
+ * cache tag to the cache keys of the build-time prerenders carrying it.
+ *
+ * It rides to S3 with the rest of the init cache, and `S3CacheHandler`'s
+ * `revalidateTag` reads it alongside the `tag#cacheKey` rows a runtime `set`
+ * writes. Without it `revalidateTag` knows a prerender is stale (see
+ * `checkIfRevalidated`) but not which CloudFront paths to invalidate, so the CDN
+ * keeps serving the old response until its TTL expires - a year, for a
+ * prerender.
+ *
+ * The leading underscore keeps it clear of cache keys, which are route paths.
+ */
+exports.INIT_CACHE_TAG_MANIFEST = "_cdk-nextjs-tag-manifest.json";
 /**
  * Helper to safely extract tags from context
  */
 function getTags(ctx) {
     return "tags" in ctx ? ctx.tags : undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-utils.js","sourceRoot":"","sources":["../../src/adapter/cache-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  Shared cache utility functions\n*/\nimport type {\n  SetIncrementalFetchCacheContext,\n  SetIncrementalResponseCacheContext,\n} from \"next/dist/server/response-cache\";\nimport { hasPathPrefix } from \"../utils/base-path\";\n\n/**\n * Pre-process value to convert Buffers and Maps before JSON.stringify\n * This is necessary because Buffer.toJSON() is called before replacer functions\n */\nfunction preprocessValue(value: any): any {\n  // Handle null/undefined\n  if (value == null) {\n    return value;\n  }\n\n  // Convert Buffer to our custom format. base64, not the array of per-byte\n  // integers this used to write (and that `Buffer.toJSON()` writes) — see\n  // {@link parseCacheValue} for why that mattered so much.\n  if (Buffer.isBuffer(value)) {\n    return {\n      __type: \"Buffer\",\n      base64: value.toString(\"base64\"),\n    };\n  }\n\n  // Convert Map to our custom format\n  if (value instanceof Map) {\n    const entries: Record<string, any> = {};\n    for (const [key, val] of value.entries()) {\n      entries[key] = preprocessValue(val);\n    }\n    return {\n      __type: \"Map\",\n      data: entries,\n    };\n  }\n\n  // Recursively process arrays\n  if (Array.isArray(value)) {\n    return value.map((item) => preprocessValue(item));\n  }\n\n  // Recursively process objects\n  if (typeof value === \"object\") {\n    const processed: Record<string, any> = {};\n    for (const [key, val] of Object.entries(value)) {\n      processed[key] = preprocessValue(val);\n    }\n    return processed;\n  }\n\n  // Return primitives as-is\n  return value;\n}\n\n/**\n * Serialize cache value with custom handling for Map and Buffer objects\n */\nexport function serializeCacheValue(value: any): string {\n  // Pre-process to convert Buffers and Maps before JSON.stringify\n  // This ensures Buffer.toJSON() doesn't interfere\n  const processed = preprocessValue(value);\n  return JSON.stringify(processed);\n}\n\n/**\n * Parse cache value with custom handling for Map and Buffer objects\n *\n * Buffers are read back from base64 when that is how they were written, and from\n * an array of per-byte integers when they were not. That array is the format\n * `Buffer.toJSON()` produces and the one this code used to write, and it is\n * ruinous for a page with a large payload: a 1 MiB prerender became ~3 MiB of\n * JSON text, an 11.6 MiB cache entry once html and the per-segment copies are\n * counted, and — because `JSON.parse`'s reviver runs for *every array element* —\n * upwards of three million reviver calls to read one page. Measured against a\n * deployment: 4.8s of Lambda time to answer a 1 MiB segment prefetch, against\n * 45ms for a small one from the same cache. base64 is 4/3 the bytes rather than\n * ~3x, and `Buffer.from(str, \"base64\")` is one native call.\n */\nexport function parseCacheValue(jsonString: string): any {\n  return JSON.parse(jsonString, (_key, val) => {\n    // Restore Map objects that were serialized with __type marker\n    if (val && typeof val === \"object\" && val.__type === \"Map\") {\n      return new Map(Object.entries(val.data));\n    }\n    // Restore Buffer objects that were serialized with __type marker (our custom format)\n    if (val && typeof val === \"object\" && val.__type === \"Buffer\") {\n      return typeof val.base64 === \"string\"\n        ? Buffer.from(val.base64, \"base64\")\n        : Buffer.from(val.data);\n    }\n    // Restore Buffer objects that were serialized with Node.js default Buffer.toJSON() format\n    // This handles legacy cache entries or runtime-generated entries\n    if (\n      val &&\n      typeof val === \"object\" &&\n      val.type === \"Buffer\" &&\n      Array.isArray(val.data)\n    ) {\n      return Buffer.from(val.data);\n    }\n    return val;\n  });\n}\n\n/**\n * The cache key a prerendered route's seeded entry has to be written under.\n *\n * `ctx.outputs.prerenders[].pathname` is the *URL* the page is served at, so it\n * carries the app's `basePath`. The key the server later looks entries up under\n * is the route, which does not — Next.js strips `basePath` before routing, so the\n * cache handler never sees it at request time. Seeding `/prod/ssg/1` verbatim\n * therefore writes `<buildId>/prod/ssg/1.json` while the server asks for\n * `<buildId>/ssg/1.json`: every build-time prerender is a MISS that re-renders on\n * first request, and the page is only \"static\" from the second visit onwards.\n */\nexport function prerenderPathToCacheKey(\n  pathname: string,\n  basePath: string,\n): string {\n  // Matching on a path boundary so a sibling route like `/production` is not\n  // read as basePath `/prod` plus `uction`.\n  const route = (\n    hasPathPrefix(pathname, basePath)\n      ? pathname.slice(basePath.length)\n      : pathname\n  )\n    // Leading slashes would make an S3 key with an empty first segment.\n    .replace(/^\\/+/, \"\");\n  return route === \"\" ? \"index\" : route;\n}\n\n/** The outputs one route contributes to `ctx.outputs.prerenders`. */\nexport interface PrerenderVariants<T> {\n  /** The HTML render. Its pathname is the route, with no suffix. */\n  html?: T;\n  /** The flight payload, built as `<route>.rsc` — but see {@link groupPrerenders}. */\n  rsc?: T;\n  /** Per-segment flight payloads, under `<route>.segments/`. */\n  segments: T[];\n  /** A Pages Router route's `pageData`, built as its `/_next/data/` route. */\n  data?: T;\n}\n\nconst INDEX_SUFFIX = \"/index\";\n\n/**\n * A Pages Router data route: `/_next/data/<buildId>/<page>.json`, optionally\n * behind a `basePath` (`normalizePathname` in Next.js's `build-complete` prefixes\n * every output pathname, this one included).\n *\n * Capture 1 is that prefix and capture 2 the page path without its `.json`, so\n * `/prod/_next/data/abc123/blog/hello.json` recomposes to `/prod/blog/hello`.\n */\nconst PAGES_DATA_PATHNAME = /^(.*)\\/_next\\/data\\/[^/]+\\/(.+)\\.json$/;\n\n/**\n * Collect `ctx.outputs.prerenders` into one entry per route.\n *\n * Next.js emits up to three shapes per prerendered App Router route — `/blog/hello`,\n * `/blog/hello.rsc`, and `/blog/hello.segments/*.segment.rsc` — and a cache entry\n * needs all of them together, so they have to be grouped by route before anything\n * can be seeded. A Pages Router route emits two: the HTML, and its `pageData` at\n * the route's `/_next/data/<buildId>/<page>.json` pathname\n * ({@link PAGES_DATA_PATHNAME}). That one is not a suffix of the page's own\n * pathname, so it is matched rather than stripped.\n *\n * The one case that is not a suffix strip is the **root route**, which cannot be\n * named `/.rsc`: its payloads are emitted under `/index.rsc` and\n * `/index.segments/` while its HTML stays at `/` (or at the `basePath`, e.g.\n * `/prod` and `/prod/index.rsc`). Reconstructing names by concatenation therefore\n * silently loses the home page's `rscData` — and with a `basePath` also its\n * `segmentData`, because `/prod` and `/prod/index` group apart. That is not a\n * cosmetic gap: `app-page-runtime.js` answers an RSC request for an entry with no\n * `rscData` by checking `cachedData.html.contentType`, and under `cacheComponents`\n * sends an empty `404`. Every client-side navigation to `/` breaks.\n *\n * The remap is conditional rather than unconditional so that an app with a real\n * page at `app/index/page.tsx` — whose HTML prerender genuinely is `/index` — keeps\n * its own group.\n */\nexport function groupPrerenders<T extends { pathname: string }>(\n  prerenders: T[],\n): Map<string, PrerenderVariants<T>> {\n  const htmlPathnames = new Set(\n    prerenders\n      .map((p) => p.pathname)\n      .filter(\n        (p) =>\n          !p.endsWith(\".rsc\") &&\n          !p.includes(\".segments/\") &&\n          !PAGES_DATA_PATHNAME.test(p),\n      ),\n  );\n  const groups = new Map<string, PrerenderVariants<T>>();\n\n  const variantsFor = (base: string): PrerenderVariants<T> => {\n    let variants = groups.get(base);\n    if (!variants) {\n      variants = { segments: [] };\n      groups.set(base, variants);\n    }\n    return variants;\n  };\n\n  /** `/index.rsc` belongs to `/`, `/prod/index.rsc` to `/prod`. */\n  const routeOf = (base: string): string => {\n    if (base.endsWith(INDEX_SUFFIX) && !htmlPathnames.has(base)) {\n      const parent = base.slice(0, -INDEX_SUFFIX.length) || \"/\";\n      if (htmlPathnames.has(parent)) {\n        return parent;\n      }\n    }\n    return base;\n  };\n\n  for (const prerender of prerenders) {\n    const { pathname } = prerender;\n    const dataRoute = PAGES_DATA_PATHNAME.exec(pathname);\n    if (dataRoute) {\n      variantsFor(routeOf(`${dataRoute[1]}/${dataRoute[2]}`)).data = prerender;\n    } else if (pathname.includes(\".segments/\")) {\n      variantsFor(routeOf(pathname.split(\".segments/\")[0])).segments.push(\n        prerender,\n      );\n    } else if (pathname.endsWith(\".rsc\")) {\n      variantsFor(routeOf(pathname.slice(0, -\".rsc\".length))).rsc = prerender;\n    } else {\n      variantsFor(pathname).html = prerender;\n    }\n  }\n\n  return groups;\n}\n\n/**\n * Headers that must not be seeded into an `APP_PAGE` cache entry, even though the\n * adapter output lists them in `fallback.initialHeaders`.\n *\n * `initialHeaders` describes how a platform should serve the prerendered *file*\n * straight off a CDN. A cache entry is a different thing: `app-page-runtime.js`\n * `appendHeader`s `cachedData.headers` onto the response and *then* serves the\n * variant the request actually asked for, so anything presentational in there is\n * either wrong or doubled. At request time Next.js stores only what the render\n * put in `metadata.headers` — `x-nextjs-stale-time`, `x-next-cache-tags`, and\n * whatever the app set through `headers()`/`cookies()` — and never these four.\n *\n * `content-type` is the one that actually breaks. `send-payload.js` sets the type\n * only when the response does not already have one\n * (`if (!res.getHeader('Content-Type') && result.contentType)`), so a seeded\n * `text/html; charset=utf-8` makes every RSC request to a prerendered page answer\n * the flight payload labeled as HTML. The client router rejects that, and so does\n * Next.js itself: `createRedirectRenderResult` checks the content type of the\n * sub-response it fetches to stream an action `redirect()`, and on a mismatch\n * cancels the body and returns an empty result.\n *\n * `vary`, `x-nextjs-prerender`, and `x-nextjs-postponed` are all set by the\n * entrypoint itself, so seeding them only produces two of each.\n *\n * `APP_ROUTE` entries are deliberately *not* filtered: a route handler's\n * `content-type` is part of its cached response, and `app-route.js` replays those\n * headers verbatim.\n */\nconst NON_CACHEABLE_APP_PAGE_HEADERS = new Set([\n  \"content-type\",\n  \"vary\",\n  \"x-nextjs-prerender\",\n  \"x-nextjs-postponed\",\n]);\n\n/** See {@link NON_CACHEABLE_APP_PAGE_HEADERS}. */\nexport function appPageCacheHeaders<T>(\n  initialHeaders: Record<string, T>,\n): Record<string, T> {\n  const headers: Record<string, T> = {};\n  for (const [name, value] of Object.entries(initialHeaders)) {\n    if (!NON_CACHEABLE_APP_PAGE_HEADERS.has(name.toLowerCase())) {\n      headers[name] = value;\n    }\n  }\n  return headers;\n}\n\n/** `NEXT_CACHE_TAGS_HEADER`, inlined so this file imports no Next.js internals. */\nconst NEXT_CACHE_TAGS_HEADER = \"x-next-cache-tags\";\n\n/**\n * The tags a cache value's render was tagged with, as Next.js records them: in\n * its `x-next-cache-tags` header, comma separated, including the implicit\n * `_N_T_/…` path chain `revalidatePath` uses. One parser for the build's tag\n * manifest and the runtime's mapping rows, which have to agree.\n *\n * `value` is `unknown` because it arrives both as a stored entry read back from\n * S3 and as the `IncrementalCacheValue` union; only some members have headers.\n */\nexport function headerTags(value: unknown): string[] {\n  const headers = (value as { headers?: Record<string, unknown> } | null)\n    ?.headers;\n  const header = headers?.[NEXT_CACHE_TAGS_HEADER];\n  return typeof header === \"string\" ? header.split(\",\").filter(Boolean) : [];\n}\n\n/**\n * Name of the file the adapter writes into the init cache directory mapping each\n * cache tag to the cache keys of the build-time prerenders carrying it.\n *\n * It rides to S3 with the rest of the init cache, and `S3CacheHandler`'s\n * `revalidateTag` reads it alongside the `tag#cacheKey` rows a runtime `set`\n * writes. Without it `revalidateTag` knows a prerender is stale (see\n * `checkIfRevalidated`) but not which CloudFront paths to invalidate, so the CDN\n * keeps serving the old response until its TTL expires - a year, for a\n * prerender.\n *\n * The leading underscore keeps it clear of cache keys, which are route paths.\n */\nexport const INIT_CACHE_TAG_MANIFEST = \"_cdk-nextjs-tag-manifest.json\";\n\n/** Contents of {@link INIT_CACHE_TAG_MANIFEST}: tag -> init cache keys. */\nexport type InitCacheTagManifest = Record<string, string[]>;\n\n/**\n * Helper to safely extract tags from context\n */\nexport function getTags(\n  ctx: SetIncrementalFetchCacheContext | SetIncrementalResponseCacheContext,\n): string[] | undefined {\n  return \"tags\" in ctx ? ctx.tags : undefined;\n}\n"]}

package/lib/adapter/cache-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/adapter/cache-utils.test.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cache_utils_1 = require("./cache-utils");
+describe("prerenderPathToCacheKey", () => {
+    it("drops the leading slash", () => {
+        expect((0, cache_utils_1.prerenderPathToCacheKey)("/ssg/1", "")).toBe("ssg/1");
+    });
+    it("maps the root route to index", () => {
+        expect((0, cache_utils_1.prerenderPathToCacheKey)("/", "")).toBe("index");
+    });
+    /**
+     * The regression that made every prerender a MISS on a deployment with a
+     * `basePath`: the seed wrote `prod/ssg/1.json` while the server, which sees the
+     * path only after Next.js has stripped `basePath`, asked for `ssg/1.json`.
+     */
+    it("strips the app's basePath", () => {
+        expect((0, cache_utils_1.prerenderPathToCacheKey)("/prod/ssg/1", "/prod")).toBe("ssg/1");
+    });
+    it("maps the basePath root to index", () => {
+        expect((0, cache_utils_1.prerenderPathToCacheKey)("/prod", "/prod")).toBe("index");
+    });
+    it("only strips basePath on a path boundary", () => {
+        expect((0, cache_utils_1.prerenderPathToCacheKey)("/production/1", "/prod")).toBe("production/1");
+    });
+});
+describe("groupPrerenders", () => {
+    const at = (...pathnames) => pathnames.map((pathname) => ({
+        pathname,
+    }));
+    it("groups a route's html, rsc and segment outputs together", () => {
+        const groups = (0, cache_utils_1.groupPrerenders)(at("/blog/hello", "/blog/hello.rsc", "/blog/hello.segments/$c$.segment.rsc", "/blog/hello.segments/$c$/__PAGE__.segment.rsc"));
+        expect(groups.size).toBe(1);
+        const variants = groups.get("/blog/hello");
+        expect(variants?.html?.pathname).toBe("/blog/hello");
+        expect(variants?.rsc?.pathname).toBe("/blog/hello.rsc");
+        expect(variants?.segments).toHaveLength(2);
+    });
+    /**
+     * The regression: the root route's HTML is emitted as `/` but its flight payload
+     * as `/index.rsc`, so grouping by a reconstructed `${route}.rsc` left `/` with no
+     * `rscData` and every client-side navigation to the home page 404'd.
+     */
+    it("gives the root route the /index.rsc payload", () => {
+        const groups = (0, cache_utils_1.groupPrerenders)(at("/", "/index.rsc", "/index.segments/$c$.segment.rsc"));
+        expect(Array.from(groups.keys())).toEqual(["/"]);
+        expect(groups.get("/")?.rsc?.pathname).toBe("/index.rsc");
+        expect(groups.get("/")?.segments).toHaveLength(1);
+    });
+    /** With a `basePath` the split is `/prod` vs `/prod/index`. */
+    it("gives the basePath root its /index.rsc payload", () => {
+        const groups = (0, cache_utils_1.groupPrerenders)(at("/prod", "/prod/index.rsc", "/prod/index.segments/$c$.segment.rsc"));
+        expect(Array.from(groups.keys())).toEqual(["/prod"]);
+        expect(groups.get("/prod")?.rsc?.pathname).toBe("/prod/index.rsc");
+        expect(groups.get("/prod")?.segments).toHaveLength(1);
+    });
+    /** An app with a real `app/index/page.tsx` keeps its own group. */
+    it("leaves a genuine /index route alone", () => {
+        const groups = (0, cache_utils_1.groupPrerenders)(at("/", "/index", "/index.rsc"));
+        expect(Array.from(groups.keys()).sort()).toEqual(["/", "/index"]);
+        expect(groups.get("/")?.rsc).toBeUndefined();
+        expect(groups.get("/index")?.rsc?.pathname).toBe("/index.rsc");
+    });
+    /** `/nested/index.rsc` with no `/nested` HTML is its own route, not a remap. */
+    it("only remaps when the parent really is a prerendered route", () => {
+        const groups = (0, cache_utils_1.groupPrerenders)(at("/nested/index.rsc"));
+        expect(Array.from(groups.keys())).toEqual(["/nested/index"]);
+    });
+    it("keeps segments whose route has no other output", () => {
+        const groups = (0, cache_utils_1.groupPrerenders)(at("/ppr.segments/$c$.segment.rsc"));
+        expect(groups.get("/ppr")?.segments).toHaveLength(1);
+        expect(groups.get("/ppr")?.html).toBeUndefined();
+    });
+    /**
+     * A Pages Router route's `pageData` lives at a pathname of its own rather than
+     * at a suffix of the page's, so an unmatched one would become a group named
+     * `/_next/data/...` - which gets no cache kind, and so silently drops the data
+     * every seeded entry needs.
+     */
+    it("attaches a Pages Router route's /_next/data output", () => {
+        const groups = (0, cache_utils_1.groupPrerenders)(at("/blog/hello", "/_next/data/build-abc123/blog/hello.json"));
+        expect(Array.from(groups.keys())).toEqual(["/blog/hello"]);
+        expect(groups.get("/blog/hello")?.data?.pathname).toBe("/_next/data/build-abc123/blog/hello.json");
+    });
+    /** The `fallback: true` template, whose data route has no file behind it. */
+    it("attaches the data output of a dynamic route's fallback template", () => {
+        const groups = (0, cache_utils_1.groupPrerenders)(at("/[slug]", "/_next/data/build-abc123/[slug].json"));
+        expect(Array.from(groups.keys())).toEqual(["/[slug]"]);
+        expect(groups.get("/[slug]")?.data?.pathname).toBe("/_next/data/build-abc123/[slug].json");
+    });
+    /** `/index.json` is the root page's data route, the same remap as `/index.rsc`. */
+    it("gives the root route its /index.json data output", () => {
+        const groups = (0, cache_utils_1.groupPrerenders)(at("/prod", "/prod/_next/data/build-abc123/index.json"));
+        expect(Array.from(groups.keys())).toEqual(["/prod"]);
+        expect(groups.get("/prod")?.data?.pathname).toBe("/prod/_next/data/build-abc123/index.json");
+    });
+});
+describe("appPageCacheHeaders", () => {
+    /** Exactly what `onBuildComplete` is handed for a prerendered app page. */
+    const initialHeaders = {
+        vary: "rsc, next-router-state-tree, next-router-prefetch, next-router-segment-prefetch",
+        "content-type": "text/html; charset=utf-8",
+        "x-nextjs-stale-time": "300",
+        "x-nextjs-prerender": "1",
+        "x-next-cache-tags": "_N_T_/layout,_N_T_/page,_N_T_/,_N_T_/index",
+    };
+    /**
+     * The regression: a seeded `content-type: text/html` survives into the response
+     * and `send-payload.js` will not overwrite it, so an RSC request to a
+     * prerendered page gets the flight payload labeled as HTML.
+     */
+    it("drops content-type, which would mislabel every RSC response", () => {
+        expect((0, cache_utils_1.appPageCacheHeaders)(initialHeaders)).not.toHaveProperty("content-type");
+    });
+    it("keeps the headers a render would really have stored", () => {
+        expect((0, cache_utils_1.appPageCacheHeaders)(initialHeaders)).toEqual({
+            "x-nextjs-stale-time": "300",
+            "x-next-cache-tags": "_N_T_/layout,_N_T_/page,_N_T_/,_N_T_/index",
+        });
+    });
+    it("drops the headers the entrypoint sets itself, which would double up", () => {
+        const headers = (0, cache_utils_1.appPageCacheHeaders)({
+            ...initialHeaders,
+            "x-nextjs-postponed": "1",
+        });
+        expect(Object.keys(headers)).not.toContain("vary");
+        expect(Object.keys(headers)).not.toContain("x-nextjs-prerender");
+        expect(Object.keys(headers)).not.toContain("x-nextjs-postponed");
+    });
+    it("matches case-insensitively", () => {
+        expect((0, cache_utils_1.appPageCacheHeaders)({ "Content-Type": "text/html" })).toEqual({});
+    });
+    it("passes through anything the app set itself", () => {
+        expect((0, cache_utils_1.appPageCacheHeaders)({ "x-custom": "1", "set-cookie": "a=b" })).toEqual({ "x-custom": "1", "set-cookie": "a=b" });
+    });
+});
+describe("serializeCacheValue / parseCacheValue", () => {
+    it("round-trips a Buffer", () => {
+        const value = { rscData: Buffer.from("hello, cache") };
+        const restored = (0, cache_utils_1.parseCacheValue)((0, cache_utils_1.serializeCacheValue)(value));
+        expect(Buffer.isBuffer(restored.rscData)).toBe(true);
+        expect(restored.rscData.toString()).toBe("hello, cache");
+    });
+    it("round-trips bytes that are not valid UTF-8", () => {
+        const value = Buffer.from([0x00, 0xff, 0xfe, 0x80, 0x7f]);
+        const restored = (0, cache_utils_1.parseCacheValue)((0, cache_utils_1.serializeCacheValue)({ value })).value;
+        expect(restored.equals(value)).toBe(true);
+    });
+    it("round-trips a Map, including Buffers inside it", () => {
+        const value = new Map([["/_index", Buffer.from("segment")]]);
+        const restored = (0, cache_utils_1.parseCacheValue)((0, cache_utils_1.serializeCacheValue)({ value })).value;
+        expect(restored).toBeInstanceOf(Map);
+        expect(restored.get("/_index").toString()).toBe("segment");
+    });
+    /**
+     * base64, not the array of per-byte integers `Buffer.toJSON()` produces: that
+     * array is ~3 bytes of JSON per byte of payload *and* makes `JSON.parse`'s
+     * reviver run once per element, which cost 4.8s of Lambda time to answer a
+     * single 1 MiB segment prefetch on a real deployment.
+     */
+    it("writes a Buffer as base64 rather than an array of bytes", () => {
+        const json = (0, cache_utils_1.serializeCacheValue)({ rscData: Buffer.from("hello") });
+        expect(JSON.parse(json).rscData).toEqual({
+            __type: "Buffer",
+            base64: "aGVsbG8=",
+        });
+        // Comfortably under the ~5 bytes per payload byte an integer array costs.
+        expect(json.length).toBeLessThan(60);
+    });
+    it("still reads the integer-array format an older build wrote", () => {
+        const legacy = JSON.stringify({
+            ours: { __type: "Buffer", data: [104, 105] },
+            nodes: { type: "Buffer", data: [104, 105] },
+        });
+        const restored = (0, cache_utils_1.parseCacheValue)(legacy);
+        expect(restored.ours.toString()).toBe("hi");
+        expect(restored.nodes.toString()).toBe("hi");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-utils.test.js","sourceRoot":"","sources":["../../src/adapter/cache-utils.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  appPageCacheHeaders,\n  groupPrerenders,\n  parseCacheValue,\n  prerenderPathToCacheKey,\n  serializeCacheValue,\n} from \"./cache-utils\";\n\ndescribe(\"prerenderPathToCacheKey\", () => {\n  it(\"drops the leading slash\", () => {\n    expect(prerenderPathToCacheKey(\"/ssg/1\", \"\")).toBe(\"ssg/1\");\n  });\n\n  it(\"maps the root route to index\", () => {\n    expect(prerenderPathToCacheKey(\"/\", \"\")).toBe(\"index\");\n  });\n\n  /**\n   * The regression that made every prerender a MISS on a deployment with a\n   * `basePath`: the seed wrote `prod/ssg/1.json` while the server, which sees the\n   * path only after Next.js has stripped `basePath`, asked for `ssg/1.json`.\n   */\n  it(\"strips the app's basePath\", () => {\n    expect(prerenderPathToCacheKey(\"/prod/ssg/1\", \"/prod\")).toBe(\"ssg/1\");\n  });\n\n  it(\"maps the basePath root to index\", () => {\n    expect(prerenderPathToCacheKey(\"/prod\", \"/prod\")).toBe(\"index\");\n  });\n\n  it(\"only strips basePath on a path boundary\", () => {\n    expect(prerenderPathToCacheKey(\"/production/1\", \"/prod\")).toBe(\n      \"production/1\",\n    );\n  });\n});\n\ndescribe(\"groupPrerenders\", () => {\n  const at = (...pathnames: string[]) =>\n    pathnames.map((pathname) => ({\n      pathname,\n    }));\n\n  it(\"groups a route's html, rsc and segment outputs together\", () => {\n    const groups = groupPrerenders(\n      at(\n        \"/blog/hello\",\n        \"/blog/hello.rsc\",\n        \"/blog/hello.segments/$c$.segment.rsc\",\n        \"/blog/hello.segments/$c$/__PAGE__.segment.rsc\",\n      ),\n    );\n    expect(groups.size).toBe(1);\n    const variants = groups.get(\"/blog/hello\");\n    expect(variants?.html?.pathname).toBe(\"/blog/hello\");\n    expect(variants?.rsc?.pathname).toBe(\"/blog/hello.rsc\");\n    expect(variants?.segments).toHaveLength(2);\n  });\n\n  /**\n   * The regression: the root route's HTML is emitted as `/` but its flight payload\n   * as `/index.rsc`, so grouping by a reconstructed `${route}.rsc` left `/` with no\n   * `rscData` and every client-side navigation to the home page 404'd.\n   */\n  it(\"gives the root route the /index.rsc payload\", () => {\n    const groups = groupPrerenders(\n      at(\"/\", \"/index.rsc\", \"/index.segments/$c$.segment.rsc\"),\n    );\n    expect(Array.from(groups.keys())).toEqual([\"/\"]);\n    expect(groups.get(\"/\")?.rsc?.pathname).toBe(\"/index.rsc\");\n    expect(groups.get(\"/\")?.segments).toHaveLength(1);\n  });\n\n  /** With a `basePath` the split is `/prod` vs `/prod/index`. */\n  it(\"gives the basePath root its /index.rsc payload\", () => {\n    const groups = groupPrerenders(\n      at(\"/prod\", \"/prod/index.rsc\", \"/prod/index.segments/$c$.segment.rsc\"),\n    );\n    expect(Array.from(groups.keys())).toEqual([\"/prod\"]);\n    expect(groups.get(\"/prod\")?.rsc?.pathname).toBe(\"/prod/index.rsc\");\n    expect(groups.get(\"/prod\")?.segments).toHaveLength(1);\n  });\n\n  /** An app with a real `app/index/page.tsx` keeps its own group. */\n  it(\"leaves a genuine /index route alone\", () => {\n    const groups = groupPrerenders(at(\"/\", \"/index\", \"/index.rsc\"));\n    expect(Array.from(groups.keys()).sort()).toEqual([\"/\", \"/index\"]);\n    expect(groups.get(\"/\")?.rsc).toBeUndefined();\n    expect(groups.get(\"/index\")?.rsc?.pathname).toBe(\"/index.rsc\");\n  });\n\n  /** `/nested/index.rsc` with no `/nested` HTML is its own route, not a remap. */\n  it(\"only remaps when the parent really is a prerendered route\", () => {\n    const groups = groupPrerenders(at(\"/nested/index.rsc\"));\n    expect(Array.from(groups.keys())).toEqual([\"/nested/index\"]);\n  });\n\n  it(\"keeps segments whose route has no other output\", () => {\n    const groups = groupPrerenders(at(\"/ppr.segments/$c$.segment.rsc\"));\n    expect(groups.get(\"/ppr\")?.segments).toHaveLength(1);\n    expect(groups.get(\"/ppr\")?.html).toBeUndefined();\n  });\n\n  /**\n   * A Pages Router route's `pageData` lives at a pathname of its own rather than\n   * at a suffix of the page's, so an unmatched one would become a group named\n   * `/_next/data/...` - which gets no cache kind, and so silently drops the data\n   * every seeded entry needs.\n   */\n  it(\"attaches a Pages Router route's /_next/data output\", () => {\n    const groups = groupPrerenders(\n      at(\"/blog/hello\", \"/_next/data/build-abc123/blog/hello.json\"),\n    );\n    expect(Array.from(groups.keys())).toEqual([\"/blog/hello\"]);\n    expect(groups.get(\"/blog/hello\")?.data?.pathname).toBe(\n      \"/_next/data/build-abc123/blog/hello.json\",\n    );\n  });\n\n  /** The `fallback: true` template, whose data route has no file behind it. */\n  it(\"attaches the data output of a dynamic route's fallback template\", () => {\n    const groups = groupPrerenders(\n      at(\"/[slug]\", \"/_next/data/build-abc123/[slug].json\"),\n    );\n    expect(Array.from(groups.keys())).toEqual([\"/[slug]\"]);\n    expect(groups.get(\"/[slug]\")?.data?.pathname).toBe(\n      \"/_next/data/build-abc123/[slug].json\",\n    );\n  });\n\n  /** `/index.json` is the root page's data route, the same remap as `/index.rsc`. */\n  it(\"gives the root route its /index.json data output\", () => {\n    const groups = groupPrerenders(\n      at(\"/prod\", \"/prod/_next/data/build-abc123/index.json\"),\n    );\n    expect(Array.from(groups.keys())).toEqual([\"/prod\"]);\n    expect(groups.get(\"/prod\")?.data?.pathname).toBe(\n      \"/prod/_next/data/build-abc123/index.json\",\n    );\n  });\n});\n\ndescribe(\"appPageCacheHeaders\", () => {\n  /** Exactly what `onBuildComplete` is handed for a prerendered app page. */\n  const initialHeaders = {\n    vary: \"rsc, next-router-state-tree, next-router-prefetch, next-router-segment-prefetch\",\n    \"content-type\": \"text/html; charset=utf-8\",\n    \"x-nextjs-stale-time\": \"300\",\n    \"x-nextjs-prerender\": \"1\",\n    \"x-next-cache-tags\": \"_N_T_/layout,_N_T_/page,_N_T_/,_N_T_/index\",\n  };\n\n  /**\n   * The regression: a seeded `content-type: text/html` survives into the response\n   * and `send-payload.js` will not overwrite it, so an RSC request to a\n   * prerendered page gets the flight payload labeled as HTML.\n   */\n  it(\"drops content-type, which would mislabel every RSC response\", () => {\n    expect(appPageCacheHeaders(initialHeaders)).not.toHaveProperty(\n      \"content-type\",\n    );\n  });\n\n  it(\"keeps the headers a render would really have stored\", () => {\n    expect(appPageCacheHeaders(initialHeaders)).toEqual({\n      \"x-nextjs-stale-time\": \"300\",\n      \"x-next-cache-tags\": \"_N_T_/layout,_N_T_/page,_N_T_/,_N_T_/index\",\n    });\n  });\n\n  it(\"drops the headers the entrypoint sets itself, which would double up\", () => {\n    const headers = appPageCacheHeaders({\n      ...initialHeaders,\n      \"x-nextjs-postponed\": \"1\",\n    });\n    expect(Object.keys(headers)).not.toContain(\"vary\");\n    expect(Object.keys(headers)).not.toContain(\"x-nextjs-prerender\");\n    expect(Object.keys(headers)).not.toContain(\"x-nextjs-postponed\");\n  });\n\n  it(\"matches case-insensitively\", () => {\n    expect(appPageCacheHeaders({ \"Content-Type\": \"text/html\" })).toEqual({});\n  });\n\n  it(\"passes through anything the app set itself\", () => {\n    expect(\n      appPageCacheHeaders({ \"x-custom\": \"1\", \"set-cookie\": \"a=b\" }),\n    ).toEqual({ \"x-custom\": \"1\", \"set-cookie\": \"a=b\" });\n  });\n});\n\ndescribe(\"serializeCacheValue / parseCacheValue\", () => {\n  it(\"round-trips a Buffer\", () => {\n    const value = { rscData: Buffer.from(\"hello, cache\") };\n\n    const restored = parseCacheValue(serializeCacheValue(value));\n\n    expect(Buffer.isBuffer(restored.rscData)).toBe(true);\n    expect(restored.rscData.toString()).toBe(\"hello, cache\");\n  });\n\n  it(\"round-trips bytes that are not valid UTF-8\", () => {\n    const value = Buffer.from([0x00, 0xff, 0xfe, 0x80, 0x7f]);\n\n    const restored = parseCacheValue(serializeCacheValue({ value })).value;\n\n    expect(restored.equals(value)).toBe(true);\n  });\n\n  it(\"round-trips a Map, including Buffers inside it\", () => {\n    const value = new Map([[\"/_index\", Buffer.from(\"segment\")]]);\n\n    const restored = parseCacheValue(serializeCacheValue({ value })).value;\n\n    expect(restored).toBeInstanceOf(Map);\n    expect(restored.get(\"/_index\").toString()).toBe(\"segment\");\n  });\n\n  /**\n   * base64, not the array of per-byte integers `Buffer.toJSON()` produces: that\n   * array is ~3 bytes of JSON per byte of payload *and* makes `JSON.parse`'s\n   * reviver run once per element, which cost 4.8s of Lambda time to answer a\n   * single 1 MiB segment prefetch on a real deployment.\n   */\n  it(\"writes a Buffer as base64 rather than an array of bytes\", () => {\n    const json = serializeCacheValue({ rscData: Buffer.from(\"hello\") });\n\n    expect(JSON.parse(json).rscData).toEqual({\n      __type: \"Buffer\",\n      base64: \"aGVsbG8=\",\n    });\n    // Comfortably under the ~5 bytes per payload byte an integer array costs.\n    expect(json.length).toBeLessThan(60);\n  });\n\n  it(\"still reads the integer-array format an older build wrote\", () => {\n    const legacy = JSON.stringify({\n      ours: { __type: \"Buffer\", data: [104, 105] },\n      nodes: { type: \"Buffer\", data: [104, 105] },\n    });\n\n    const restored = parseCacheValue(legacy);\n\n    expect(restored.ours.toString()).toBe(\"hi\");\n    expect(restored.nodes.toString()).toBe(\"hi\");\n  });\n});\n"]}