cdk-nextjs 0.6.1 → 0.7.0

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

@@ -0,0 +1,6 @@
+import type { BuildCompleteContext } from "./build-outputs";
+/**
+ * Write a `<cacheKey>.json` per prerendered route under `cacheDir`, plus
+ * {@link INIT_CACHE_TAG_MANIFEST} when any entry carries tags.
+ */
+export declare function writeInitCache(ctx: Pick<BuildCompleteContext, "config" | "outputs">, cacheDir: string): Promise<void>;

package/lib/adapter/init-cache.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeInitCache = writeInitCache;
+/* eslint-disable import/no-extraneous-dependencies */
+/**
+ * The init cache: one response-cache entry per prerendered route, written by
+ * `onBuildComplete` and seeded into S3 at deploy, so a fresh
+ * deployment starts with what `next build` rendered instead of a cold cache.
+ *
+ * Separate from `adapter.mts` only so it can be tested without loading the
+ * adapter itself (which resolves cdk-nextjs's own handlers off `import.meta`).
+ */
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const debug_1 = __importDefault(require("debug"));
+const cache_kinds_1 = require("./cache-kinds");
+const cache_utils_1 = require("./cache-utils");
+const debug = (0, debug_1.default)("cdk-nextjs:adapter");
+/**
+ * Write a `<cacheKey>.json` per prerendered route under `cacheDir`, plus
+ * {@link INIT_CACHE_TAG_MANIFEST} when any entry carries tags.
+ */
+async function writeInitCache(ctx, cacheDir) {
+    // Ensure cache directory exists
+    await (0, promises_1.mkdir)(cacheDir, { recursive: true });
+    debug(`Init cache directory: ${cacheDir}`);
+    // One entry per route, with its HTML, `.rsc` and segment outputs together
+    const prerenderGroups = (0, cache_utils_1.groupPrerenders)(ctx.outputs.prerenders);
+    debug(`Prerender groups: ${prerenderGroups.size} groups`);
+    const cacheKindOf = (0, cache_kinds_1.cacheKindResolver)(ctx.outputs);
+    // Tag -> cache keys, standing in for the mapping rows a runtime `set` writes.
+    // See `INIT_CACHE_TAG_MANIFEST`.
+    const tagManifest = {};
+    // Process each group and create cache entries
+    for (const [basePath, variants] of prerenderGroups) {
+        try {
+            // A dynamic route template — `/[lang]/[slug]` — is not a dead entry: with
+            // PPR it is the route's *fallback shell*, and the server looks it up in
+            // the cache under exactly that key. `app-page-runtime` reads
+            // `prerenderManifest.dynamicRoutes[route].fallback` (the literal template
+            // string) and calls `handleResponse({ cacheKey, isFallback: true })`; the
+            // Pages Router does the same with `srcPage` for an ISR fallback. Skipping
+            // these groups made every such lookup a MISS, so the shell was rendered
+            // per request instead of resumed from the build - visible in
+            // `test/e2e/app-dir/sub-shell-generation`, where a `'use cache'` root
+            // layout reported `(runtime)` where next start reports `(buildtime)`.
+            //
+            // A Pages Router template is seeded for the same reason: in production
+            // its fill function only returns what the cache already holds, so with
+            // nothing seeded there is no `fallback: true` shell to serve and
+            // `router.isFallback` is never true (`test/e2e/fallback-route-params`).
+            // Nothing extra is needed to keep non-PPR templates out: a route with no
+            // shell emits no prerender output.
+            const kind = cacheKindOf(variants);
+            if (!kind) {
+                debug(`SKIP: No route kind found for ${basePath}`);
+                continue;
+            }
+            debug(`Processing ${basePath} (${kind})`);
+            const { html: htmlPrerender, rsc: rscPrerender, segments: segmentPrerenders, data: dataPrerender, } = variants;
+            if (!htmlPrerender && !rscPrerender && !dataPrerender) {
+                debug(`SKIP: No prerender files found for ${basePath}`);
+                continue; // Skip if we don't have the main files
+            }
+            // Create cache entry with the appropriate structure based on kind
+            let cacheEntry;
+            if (kind === "APP_PAGE" /* CachedRouteKind.APP_PAGE */) {
+                // Read HTML file
+                const html = await readPrerenderAsText(htmlPrerender);
+                if (!html) {
+                    debug(`SKIP: No HTML content for APP_PAGE ${basePath}`);
+                    continue; // Skip if no HTML content
+                }
+                // Read RSC data
+                const rscData = await readPrerenderAsBuffer(rscPrerender);
+                // Read segment data
+                const segmentData = await getSegmentData(segmentPrerenders);
+                // Extract headers from the HTML or RSC prerender
+                const headers = (0, cache_utils_1.appPageCacheHeaders)(htmlPrerender?.fallback?.initialHeaders ||
+                    rscPrerender?.fallback?.initialHeaders ||
+                    {});
+                cacheEntry = {
+                    lastModified: Date.now(),
+                    value: {
+                        kind: "APP_PAGE" /* CachedRouteKind.APP_PAGE */,
+                        html,
+                        rscData,
+                        headers,
+                        segmentData: segmentData,
+                        // postponedState from fallback appears to be the React postponed state
+                        // which matches what the cache expects for postponed
+                        postponed: htmlPrerender?.fallback?.postponedState,
+                        // initialStatus from prerender is the HTTP status of the prerendered page
+                        status: htmlPrerender?.fallback?.initialStatus,
+                    },
+                };
+            }
+            else if (kind === "APP_ROUTE" /* CachedRouteKind.APP_ROUTE */) {
+                const body = await readPrerenderAsBuffer(htmlPrerender);
+                if (!body) {
+                    debug(`SKIP: No body content for APP_ROUTE ${basePath}`);
+                    continue; // Skip if no content
+                }
+                // Extract headers
+                const headers = htmlPrerender?.fallback?.initialHeaders || {};
+                cacheEntry = {
+                    lastModified: Date.now(),
+                    value: {
+                        kind: "APP_ROUTE" /* CachedRouteKind.APP_ROUTE */,
+                        body,
+                        headers,
+                        status: htmlPrerender?.fallback?.initialStatus || 200,
+                    },
+                };
+            }
+            else if (kind === "PAGES" /* CachedRouteKind.PAGES */) {
+                // A build-time `notFound: true`. Next.js reports the route as
+                // prerendered and hands us a prerender whose `filePath` is
+                // `pages/404.html` and whose `initialStatus` is 404 - but it writes
+                // *no* output for it (no `first.html`, `.json` or `.meta`), because a
+                // Pages Router `notFound` is represented in the cache as an entry
+                // whose `value` is `null` (`pages-handler.ts`, "isNotFound in
+                // metadata"), and `FileSystemCache.set` keeps a null value in its LRU
+                // only, never on disk. So `next start` misses, re-runs
+                // `getStaticProps`, and answers 404 from `render404()`.
+                //
+                // Seeding it as an ordinary `PAGES` entry made that a 200: the entry
+                // is a HIT carrying the 404 page's HTML, and the pages handler never
+                // reads `value.status` on the HIT path, so the status stayed 200 while
+                // the body said "404 page". Skipping it restores the miss, and with it
+                // `next start`'s status. Costs one render per revalidate window, which
+                // is what `next start` pays too.
+                const initialStatus = htmlPrerender?.fallback?.initialStatus;
+                if (initialStatus !== undefined && initialStatus !== 200) {
+                    debug(`SKIP: PAGES ${basePath} prerendered with status ${initialStatus} (build-time notFound)`);
+                    continue;
+                }
+                const html = await readPrerenderAsText(htmlPrerender);
+                if (!html) {
+                    debug(`SKIP: No HTML content for PAGES ${basePath}`);
+                    continue;
+                }
+                // `getStaticProps`' result, which the entrypoint answers
+                // `/_next/data/<buildId>/<page>.json` with and the client router reads
+                // on a navigation. A route's *fallback* template has no data file -
+                // there are no params to run `getStaticProps` with yet - and
+                // `FileSystemCache` skips the read for one too (`if (!ctx.isFallback)`),
+                // leaving `pageData` an empty object.
+                const pageDataJson = await readPrerenderAsText(dataPrerender);
+                cacheEntry = {
+                    lastModified: Date.now(),
+                    value: {
+                        kind: "PAGES" /* CachedRouteKind.PAGES */,
+                        html,
+                        pageData: pageDataJson ? JSON.parse(pageDataJson) : {},
+                        // Both `undefined`, which is what `FileSystemCache` hands back for
+                        // a `PAGES` entry: it reads a `.meta` sidecar for the App Router
+                        // kinds only, and `sendRenderResult` supplies the content type.
+                        // Seeding `fallback.initialHeaders` instead would put
+                        // `content-type: text/html` on the JSON data responses served from
+                        // this same entry.
+                        headers: undefined,
+                        status: undefined,
+                    },
+                };
+            }
+            else {
+                // Skip unsupported kinds
+                debug(`SKIP: Unsupported route kind ${kind} for ${basePath}`);
+                continue;
+            }
+            // Write cache entry to file, under the route rather than the URL it is
+            // served at - see `prerenderPathToCacheKey`.
+            const cacheKey = (0, cache_utils_1.prerenderPathToCacheKey)(basePath, ctx.config.basePath || "");
+            const cacheFilePath = (0, node_path_1.join)(cacheDir, `${cacheKey}.json`);
+            // Ensure parent directory exists
+            await (0, promises_1.mkdir)((0, node_path_1.join)(cacheDir, cacheKey.split("/").slice(0, -1).join("/")), {
+                recursive: true,
+            });
+            await (0, promises_1.writeFile)(cacheFilePath, (0, cache_utils_1.serializeCacheValue)(cacheEntry));
+            for (const tag of (0, cache_utils_1.headerTags)(cacheEntry.value)) {
+                (tagManifest[tag] ??= []).push(cacheKey);
+            }
+            debug(`Created cache entry: ${cacheFilePath}`);
+        }
+        catch (error) {
+            console.error(`Error processing prerender group ${basePath}:`, error);
+        }
+    }
+    const taggedKeys = Object.keys(tagManifest).length;
+    if (taggedKeys > 0) {
+        await (0, promises_1.writeFile)((0, node_path_1.join)(cacheDir, cache_utils_1.INIT_CACHE_TAG_MANIFEST), JSON.stringify(tagManifest));
+        debug(`Wrote ${cache_utils_1.INIT_CACHE_TAG_MANIFEST} with ${taggedKeys} tags`);
+    }
+}
+/**
+ * Read file content from a prerender as UTF-8 string
+ */
+async function readPrerenderAsText(prerender) {
+    if (prerender?.fallback &&
+        "filePath" in prerender.fallback &&
+        prerender.fallback.filePath &&
+        (0, node_fs_1.existsSync)(prerender.fallback.filePath)) {
+        return (0, promises_1.readFile)(prerender.fallback.filePath, "utf-8");
+    }
+    return undefined;
+}
+/**
+ * Read file content from a prerender as Buffer
+ */
+async function readPrerenderAsBuffer(prerender) {
+    if (prerender?.fallback &&
+        "filePath" in prerender.fallback &&
+        prerender.fallback.filePath &&
+        (0, node_fs_1.existsSync)(prerender.fallback.filePath)) {
+        return (0, promises_1.readFile)(prerender.fallback.filePath);
+    }
+    return undefined;
+}
+/**
+ * Read segment data from segment prerenders
+ */
+async function getSegmentData(segmentPrerenders) {
+    const segmentData = new Map();
+    for (const segmentPrerender of segmentPrerenders) {
+        if (segmentPrerender.fallback &&
+            "filePath" in segmentPrerender.fallback &&
+            segmentPrerender.fallback.filePath &&
+            (0, node_fs_1.existsSync)(segmentPrerender.fallback.filePath)) {
+            const segmentContent = await (0, promises_1.readFile)(segmentPrerender.fallback.filePath);
+            // Extract segment name from pathname
+            const segmentName = "/" +
+                segmentPrerender.pathname
+                    .split(".segments/")[1]
+                    .replace(/\.segment\.rsc$/, "");
+            segmentData.set(segmentName, segmentContent);
+        }
+    }
+    return segmentData;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"init-cache.js","sourceRoot":"","sources":["../../src/adapter/init-cache.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\n/**\n * The init cache: one response-cache entry per prerendered route, written by\n * `onBuildComplete` and seeded into S3 at deploy, so a fresh\n * deployment starts with what `next build` rendered instead of a cold cache.\n *\n * Separate from `adapter.mts` only so it can be tested without loading the\n * adapter itself (which resolves cdk-nextjs's own handlers off `import.meta`).\n */\nimport { existsSync } from \"node:fs\";\nimport { mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport getDebug from \"debug\";\nimport { CacheHandlerValue } from \"next/dist/server/lib/incremental-cache\";\nimport { CachedRouteKind } from \"next/dist/server/response-cache/index.js\";\nimport type { BuildCompleteContext } from \"./build-outputs\";\nimport { cacheKindResolver } from \"./cache-kinds\";\nimport {\n  appPageCacheHeaders,\n  groupPrerenders,\n  headerTags,\n  INIT_CACHE_TAG_MANIFEST,\n  InitCacheTagManifest,\n  prerenderPathToCacheKey,\n  serializeCacheValue,\n} from \"./cache-utils\";\n\nconst debug = getDebug(\"cdk-nextjs:adapter\");\n\n/**\n * Write a `<cacheKey>.json` per prerendered route under `cacheDir`, plus\n * {@link INIT_CACHE_TAG_MANIFEST} when any entry carries tags.\n */\nexport async function writeInitCache(\n  ctx: Pick<BuildCompleteContext, \"config\" | \"outputs\">,\n  cacheDir: string,\n): Promise<void> {\n  // Ensure cache directory exists\n  await mkdir(cacheDir, { recursive: true });\n  debug(`Init cache directory: ${cacheDir}`);\n\n  // One entry per route, with its HTML, `.rsc` and segment outputs together\n  const prerenderGroups = groupPrerenders(ctx.outputs.prerenders);\n  debug(`Prerender groups: ${prerenderGroups.size} groups`);\n\n  const cacheKindOf = cacheKindResolver(ctx.outputs);\n\n  // Tag -> cache keys, standing in for the mapping rows a runtime `set` writes.\n  // See `INIT_CACHE_TAG_MANIFEST`.\n  const tagManifest: InitCacheTagManifest = {};\n\n  // Process each group and create cache entries\n  for (const [basePath, variants] of prerenderGroups) {\n    try {\n      // A dynamic route template — `/[lang]/[slug]` — is not a dead entry: with\n      // PPR it is the route's *fallback shell*, and the server looks it up in\n      // the cache under exactly that key. `app-page-runtime` reads\n      // `prerenderManifest.dynamicRoutes[route].fallback` (the literal template\n      // string) and calls `handleResponse({ cacheKey, isFallback: true })`; the\n      // Pages Router does the same with `srcPage` for an ISR fallback. Skipping\n      // these groups made every such lookup a MISS, so the shell was rendered\n      // per request instead of resumed from the build - visible in\n      // `test/e2e/app-dir/sub-shell-generation`, where a `'use cache'` root\n      // layout reported `(runtime)` where next start reports `(buildtime)`.\n      //\n      // A Pages Router template is seeded for the same reason: in production\n      // its fill function only returns what the cache already holds, so with\n      // nothing seeded there is no `fallback: true` shell to serve and\n      // `router.isFallback` is never true (`test/e2e/fallback-route-params`).\n      // Nothing extra is needed to keep non-PPR templates out: a route with no\n      // shell emits no prerender output.\n      const kind = cacheKindOf(variants);\n      if (!kind) {\n        debug(`SKIP: No route kind found for ${basePath}`);\n        continue;\n      }\n\n      debug(`Processing ${basePath} (${kind})`);\n\n      const {\n        html: htmlPrerender,\n        rsc: rscPrerender,\n        segments: segmentPrerenders,\n        data: dataPrerender,\n      } = variants;\n\n      if (!htmlPrerender && !rscPrerender && !dataPrerender) {\n        debug(`SKIP: No prerender files found for ${basePath}`);\n        continue; // Skip if we don't have the main files\n      }\n\n      // Create cache entry with the appropriate structure based on kind\n      let cacheEntry: CacheHandlerValue;\n\n      if (kind === CachedRouteKind.APP_PAGE) {\n        // Read HTML file\n        const html = await readPrerenderAsText(htmlPrerender);\n\n        if (!html) {\n          debug(`SKIP: No HTML content for APP_PAGE ${basePath}`);\n          continue; // Skip if no HTML content\n        }\n\n        // Read RSC data\n        const rscData = await readPrerenderAsBuffer(rscPrerender);\n\n        // Read segment data\n        const segmentData = await getSegmentData(segmentPrerenders);\n\n        // Extract headers from the HTML or RSC prerender\n        const headers = appPageCacheHeaders(\n          htmlPrerender?.fallback?.initialHeaders ||\n            rscPrerender?.fallback?.initialHeaders ||\n            {},\n        );\n\n        cacheEntry = {\n          lastModified: Date.now(),\n          value: {\n            kind: CachedRouteKind.APP_PAGE,\n            html,\n            rscData,\n            headers,\n            segmentData: segmentData,\n            // postponedState from fallback appears to be the React postponed state\n            // which matches what the cache expects for postponed\n            postponed: htmlPrerender?.fallback?.postponedState,\n            // initialStatus from prerender is the HTTP status of the prerendered page\n            status: htmlPrerender?.fallback?.initialStatus,\n          },\n        };\n      } else if (kind === CachedRouteKind.APP_ROUTE) {\n        const body = await readPrerenderAsBuffer(htmlPrerender);\n\n        if (!body) {\n          debug(`SKIP: No body content for APP_ROUTE ${basePath}`);\n          continue; // Skip if no content\n        }\n\n        // Extract headers\n        const headers = htmlPrerender?.fallback?.initialHeaders || {};\n\n        cacheEntry = {\n          lastModified: Date.now(),\n          value: {\n            kind: CachedRouteKind.APP_ROUTE,\n            body,\n            headers,\n            status: htmlPrerender?.fallback?.initialStatus || 200,\n          },\n        };\n      } else if (kind === CachedRouteKind.PAGES) {\n        // A build-time `notFound: true`. Next.js reports the route as\n        // prerendered and hands us a prerender whose `filePath` is\n        // `pages/404.html` and whose `initialStatus` is 404 - but it writes\n        // *no* output for it (no `first.html`, `.json` or `.meta`), because a\n        // Pages Router `notFound` is represented in the cache as an entry\n        // whose `value` is `null` (`pages-handler.ts`, \"isNotFound in\n        // metadata\"), and `FileSystemCache.set` keeps a null value in its LRU\n        // only, never on disk. So `next start` misses, re-runs\n        // `getStaticProps`, and answers 404 from `render404()`.\n        //\n        // Seeding it as an ordinary `PAGES` entry made that a 200: the entry\n        // is a HIT carrying the 404 page's HTML, and the pages handler never\n        // reads `value.status` on the HIT path, so the status stayed 200 while\n        // the body said \"404 page\". Skipping it restores the miss, and with it\n        // `next start`'s status. Costs one render per revalidate window, which\n        // is what `next start` pays too.\n        const initialStatus = htmlPrerender?.fallback?.initialStatus;\n        if (initialStatus !== undefined && initialStatus !== 200) {\n          debug(\n            `SKIP: PAGES ${basePath} prerendered with status ${initialStatus} (build-time notFound)`,\n          );\n          continue;\n        }\n\n        const html = await readPrerenderAsText(htmlPrerender);\n\n        if (!html) {\n          debug(`SKIP: No HTML content for PAGES ${basePath}`);\n          continue;\n        }\n\n        // `getStaticProps`' result, which the entrypoint answers\n        // `/_next/data/<buildId>/<page>.json` with and the client router reads\n        // on a navigation. A route's *fallback* template has no data file -\n        // there are no params to run `getStaticProps` with yet - and\n        // `FileSystemCache` skips the read for one too (`if (!ctx.isFallback)`),\n        // leaving `pageData` an empty object.\n        const pageDataJson = await readPrerenderAsText(dataPrerender);\n\n        cacheEntry = {\n          lastModified: Date.now(),\n          value: {\n            kind: CachedRouteKind.PAGES,\n            html,\n            pageData: pageDataJson ? JSON.parse(pageDataJson) : {},\n            // Both `undefined`, which is what `FileSystemCache` hands back for\n            // a `PAGES` entry: it reads a `.meta` sidecar for the App Router\n            // kinds only, and `sendRenderResult` supplies the content type.\n            // Seeding `fallback.initialHeaders` instead would put\n            // `content-type: text/html` on the JSON data responses served from\n            // this same entry.\n            headers: undefined,\n            status: undefined,\n          },\n        };\n      } else {\n        // Skip unsupported kinds\n        debug(`SKIP: Unsupported route kind ${kind} for ${basePath}`);\n        continue;\n      }\n\n      // Write cache entry to file, under the route rather than the URL it is\n      // served at - see `prerenderPathToCacheKey`.\n      const cacheKey = prerenderPathToCacheKey(\n        basePath,\n        ctx.config.basePath || \"\",\n      );\n      const cacheFilePath = join(cacheDir, `${cacheKey}.json`);\n\n      // Ensure parent directory exists\n      await mkdir(join(cacheDir, cacheKey.split(\"/\").slice(0, -1).join(\"/\")), {\n        recursive: true,\n      });\n\n      await writeFile(cacheFilePath, serializeCacheValue(cacheEntry));\n\n      for (const tag of headerTags(cacheEntry.value)) {\n        (tagManifest[tag] ??= []).push(cacheKey);\n      }\n\n      debug(`Created cache entry: ${cacheFilePath}`);\n    } catch (error) {\n      console.error(`Error processing prerender group ${basePath}:`, error);\n    }\n  }\n\n  const taggedKeys = Object.keys(tagManifest).length;\n  if (taggedKeys > 0) {\n    await writeFile(\n      join(cacheDir, INIT_CACHE_TAG_MANIFEST),\n      JSON.stringify(tagManifest),\n    );\n    debug(`Wrote ${INIT_CACHE_TAG_MANIFEST} with ${taggedKeys} tags`);\n  }\n}\n\n/**\n * Read file content from a prerender as UTF-8 string\n */\nasync function readPrerenderAsText(\n  prerender:\n    | { fallback?: { filePath?: string } | { postponedState: string } }\n    | undefined,\n): Promise<string | undefined> {\n  if (\n    prerender?.fallback &&\n    \"filePath\" in prerender.fallback &&\n    prerender.fallback.filePath &&\n    existsSync(prerender.fallback.filePath)\n  ) {\n    return readFile(prerender.fallback.filePath, \"utf-8\");\n  }\n  return undefined;\n}\n\n/**\n * Read file content from a prerender as Buffer\n */\nasync function readPrerenderAsBuffer(\n  prerender:\n    | { fallback?: { filePath?: string } | { postponedState: string } }\n    | undefined,\n): Promise<Buffer | undefined> {\n  if (\n    prerender?.fallback &&\n    \"filePath\" in prerender.fallback &&\n    prerender.fallback.filePath &&\n    existsSync(prerender.fallback.filePath)\n  ) {\n    return readFile(prerender.fallback.filePath);\n  }\n  return undefined;\n}\n\n/**\n * Read segment data from segment prerenders\n */\nasync function getSegmentData<\n  T extends {\n    pathname: string;\n    fallback?: { filePath?: string } | { postponedState: string };\n  },\n>(segmentPrerenders: T[]): Promise<Map<string, Buffer>> {\n  const segmentData = new Map<string, Buffer>();\n\n  for (const segmentPrerender of segmentPrerenders) {\n    if (\n      segmentPrerender.fallback &&\n      \"filePath\" in segmentPrerender.fallback &&\n      segmentPrerender.fallback.filePath &&\n      existsSync(segmentPrerender.fallback.filePath)\n    ) {\n      const segmentContent = await readFile(segmentPrerender.fallback.filePath);\n      // Extract segment name from pathname\n      const segmentName =\n        \"/\" +\n        segmentPrerender.pathname\n          .split(\".segments/\")[1]\n          .replace(/\\.segment\\.rsc$/, \"\");\n      segmentData.set(segmentName, segmentContent);\n    }\n  }\n\n  return segmentData;\n}\n"]}

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

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

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const cache_utils_1 = require("./cache-utils");
+const init_cache_1 = require("./init-cache");
+let dir;
+let cacheDir;
+beforeEach(async () => {
+    dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "init-cache-test-"));
+    cacheDir = (0, node_path_1.join)(dir, "cache");
+});
+afterEach(async () => {
+    await (0, promises_1.rm)(dir, { recursive: true, force: true });
+});
+/** A prerender output as `next build` hands it to `onBuildComplete`. */
+async function prerender(pathname, parentOutputId, body, fallback = {}) {
+    const filePath = (0, node_path_1.join)(dir, `${pathname.replace(/\//g, "_")}.out`);
+    await (0, promises_1.writeFile)(filePath, body);
+    return { pathname, parentOutputId, fallback: { filePath, ...fallback } };
+}
+function context(prerenders, basePath = "") {
+    return {
+        config: { basePath },
+        outputs: {
+            pages: [{ id: "/blog/[slug]" }, { id: "/gone" }],
+            appPages: [{ id: "/shop" }, { id: "/isr/[id]" }],
+            appRoutes: [{ id: "/feed.xml" }],
+            pagesApi: [],
+            prerenders,
+            staticFiles: [],
+        },
+    };
+}
+const readEntry = async (key) => JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(cacheDir, `${key}.json`), "utf8"));
+describe("writeInitCache", () => {
+    it("seeds each kind with the shape the cache handler reads", async () => {
+        const ctx = context([
+            await prerender("/shop", "/shop", "<html>shop</html>", {
+                initialStatus: 200,
+                postponedState: undefined,
+                initialHeaders: {
+                    "content-type": "text/html; charset=utf-8",
+                    "x-next-cache-tags": "shop,_N_T_/shop",
+                },
+            }),
+            await prerender("/shop.rsc", "/shop", "flight"),
+            await prerender("/shop.segments/_tree.segment.rsc", "/shop", "tree"),
+            await prerender("/feed.xml", "/feed.xml", "<rss/>", {
+                initialHeaders: { "content-type": "application/xml" },
+            }),
+            await prerender("/blog/hello", "/blog/[slug]", "<html>hello</html>", {
+                initialStatus: 200,
+                initialHeaders: { "content-type": "text/html" },
+            }),
+            await prerender("/_next/data/build/blog/hello.json", "/blog/[slug]", JSON.stringify({ pageProps: { slug: "hello" } })),
+        ]);
+        await (0, init_cache_1.writeInitCache)(ctx, cacheDir);
+        const shop = await readEntry("shop");
+        expect(shop.value.kind).toBe("APP_PAGE");
+        expect(shop.value.html).toBe("<html>shop</html>");
+        expect(shop.value.status).toBe(200);
+        // Presentational headers stay out of an APP_PAGE entry; the render's own
+        // (cache tags) stay in.
+        expect(shop.value.headers).toEqual({
+            "x-next-cache-tags": "shop,_N_T_/shop",
+        });
+        expect(JSON.stringify(shop.value.rscData)).toContain(Buffer.from("flight").toString("base64"));
+        expect(JSON.stringify(shop.value.segmentData)).toContain("/_tree");
+        const feed = await readEntry("feed.xml");
+        expect(feed.value.kind).toBe("APP_ROUTE");
+        expect(feed.value.status).toBe(200);
+        expect(feed.value.headers).toEqual({ "content-type": "application/xml" });
+        const hello = await readEntry("blog/hello");
+        expect(hello.value.kind).toBe("PAGES");
+        expect(hello.value.html).toBe("<html>hello</html>");
+        expect(hello.value.pageData).toEqual({ pageProps: { slug: "hello" } });
+        // `FileSystemCache` hands a PAGES entry back without headers; seeding
+        // `initialHeaders` would label its JSON data responses text/html.
+        expect(hello.value.headers).toBeUndefined();
+    });
+    it("seeds a dynamic route's template under its own key, with the PPR shell's postponed state", async () => {
+        // With PPR the template is the route's fallback shell, looked up under the
+        // literal template key; the Pages Router looks up an ISR fallback the same
+        // way. Unseeded, every such lookup missed and the shell rendered per request.
+        const ctx = context([
+            await prerender("/isr/[id]", "/isr/[id]", "<html>shell</html>", {
+                initialStatus: 200,
+                postponedState: "postponed-state",
+            }),
+            await prerender("/isr/[id].rsc", "/isr/[id]", "flight"),
+            await prerender("/blog/[slug]", "/blog/[slug]", "<html>fallback</html>", {
+                initialStatus: 200,
+            }),
+        ]);
+        await (0, init_cache_1.writeInitCache)(ctx, cacheDir);
+        const shell = await readEntry("isr/[id]");
+        expect(shell.value.kind).toBe("APP_PAGE");
+        expect(shell.value.html).toBe("<html>shell</html>");
+        expect(shell.value.postponed).toBe("postponed-state");
+        const fallback = await readEntry("blog/[slug]");
+        expect(fallback.value.kind).toBe("PAGES");
+        expect(fallback.value.html).toBe("<html>fallback</html>");
+    });
+    it("skips a Pages Router route prerendered with a non-200 status", async () => {
+        // A build-time `notFound: true`: seeding it would be a 200 HIT with the 404
+        // page's HTML.
+        const ctx = context([
+            await prerender("/gone", "/gone", "<html>404</html>", {
+                initialStatus: 404,
+            }),
+        ]);
+        await (0, init_cache_1.writeInitCache)(ctx, cacheDir);
+        expect((0, node_fs_1.existsSync)((0, node_path_1.join)(cacheDir, "gone.json"))).toBe(false);
+    });
+    it("maps each tag to the keys carrying it, under basePath-less keys", async () => {
+        const ctx = context([
+            await prerender("/docs/shop", "/shop", "<html>a</html>", {
+                initialHeaders: { "x-next-cache-tags": "products,_N_T_/shop" },
+            }),
+        ], "/docs");
+        await (0, init_cache_1.writeInitCache)(ctx, cacheDir);
+        const manifest = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(cacheDir, cache_utils_1.INIT_CACHE_TAG_MANIFEST), "utf8"));
+        expect(manifest).toEqual({
+            products: ["shop"],
+            "_N_T_/shop": ["shop"],
+        });
+    });
+    it("writes no tag manifest when nothing is tagged", async () => {
+        const ctx = context([await prerender("/feed.xml", "/feed.xml", "<rss/>")]);
+        await (0, init_cache_1.writeInitCache)(ctx, cacheDir);
+        expect(await (0, promises_1.readdir)(cacheDir)).toEqual(["feed.xml.json"]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"init-cache.test.js","sourceRoot":"","sources":["../../src/adapter/init-cache.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync } from \"node:fs\";\nimport { mkdtemp, readFile, readdir, rm, writeFile } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport type { BuildCompleteContext } from \"./build-outputs\";\nimport { INIT_CACHE_TAG_MANIFEST } from \"./cache-utils\";\nimport { writeInitCache } from \"./init-cache\";\n\nlet dir: string;\nlet cacheDir: string;\n\nbeforeEach(async () => {\n  dir = await mkdtemp(join(tmpdir(), \"init-cache-test-\"));\n  cacheDir = join(dir, \"cache\");\n});\n\nafterEach(async () => {\n  await rm(dir, { recursive: true, force: true });\n});\n\n/** A prerender output as `next build` hands it to `onBuildComplete`. */\nasync function prerender(\n  pathname: string,\n  parentOutputId: string,\n  body: string,\n  fallback: Record<string, unknown> = {},\n) {\n  const filePath = join(dir, `${pathname.replace(/\\//g, \"_\")}.out`);\n  await writeFile(filePath, body);\n  return { pathname, parentOutputId, fallback: { filePath, ...fallback } };\n}\n\nfunction context(\n  prerenders: unknown[],\n  basePath = \"\",\n): Pick<BuildCompleteContext, \"config\" | \"outputs\"> {\n  return {\n    config: { basePath },\n    outputs: {\n      pages: [{ id: \"/blog/[slug]\" }, { id: \"/gone\" }],\n      appPages: [{ id: \"/shop\" }, { id: \"/isr/[id]\" }],\n      appRoutes: [{ id: \"/feed.xml\" }],\n      pagesApi: [],\n      prerenders,\n      staticFiles: [],\n    },\n  } as unknown as Pick<BuildCompleteContext, \"config\" | \"outputs\">;\n}\n\nconst readEntry = async (key: string) =>\n  JSON.parse(await readFile(join(cacheDir, `${key}.json`), \"utf8\"));\n\ndescribe(\"writeInitCache\", () => {\n  it(\"seeds each kind with the shape the cache handler reads\", async () => {\n    const ctx = context([\n      await prerender(\"/shop\", \"/shop\", \"<html>shop</html>\", {\n        initialStatus: 200,\n        postponedState: undefined,\n        initialHeaders: {\n          \"content-type\": \"text/html; charset=utf-8\",\n          \"x-next-cache-tags\": \"shop,_N_T_/shop\",\n        },\n      }),\n      await prerender(\"/shop.rsc\", \"/shop\", \"flight\"),\n      await prerender(\"/shop.segments/_tree.segment.rsc\", \"/shop\", \"tree\"),\n      await prerender(\"/feed.xml\", \"/feed.xml\", \"<rss/>\", {\n        initialHeaders: { \"content-type\": \"application/xml\" },\n      }),\n      await prerender(\"/blog/hello\", \"/blog/[slug]\", \"<html>hello</html>\", {\n        initialStatus: 200,\n        initialHeaders: { \"content-type\": \"text/html\" },\n      }),\n      await prerender(\n        \"/_next/data/build/blog/hello.json\",\n        \"/blog/[slug]\",\n        JSON.stringify({ pageProps: { slug: \"hello\" } }),\n      ),\n    ]);\n    await writeInitCache(ctx, cacheDir);\n\n    const shop = await readEntry(\"shop\");\n    expect(shop.value.kind).toBe(\"APP_PAGE\");\n    expect(shop.value.html).toBe(\"<html>shop</html>\");\n    expect(shop.value.status).toBe(200);\n    // Presentational headers stay out of an APP_PAGE entry; the render's own\n    // (cache tags) stay in.\n    expect(shop.value.headers).toEqual({\n      \"x-next-cache-tags\": \"shop,_N_T_/shop\",\n    });\n    expect(JSON.stringify(shop.value.rscData)).toContain(\n      Buffer.from(\"flight\").toString(\"base64\"),\n    );\n    expect(JSON.stringify(shop.value.segmentData)).toContain(\"/_tree\");\n\n    const feed = await readEntry(\"feed.xml\");\n    expect(feed.value.kind).toBe(\"APP_ROUTE\");\n    expect(feed.value.status).toBe(200);\n    expect(feed.value.headers).toEqual({ \"content-type\": \"application/xml\" });\n\n    const hello = await readEntry(\"blog/hello\");\n    expect(hello.value.kind).toBe(\"PAGES\");\n    expect(hello.value.html).toBe(\"<html>hello</html>\");\n    expect(hello.value.pageData).toEqual({ pageProps: { slug: \"hello\" } });\n    // `FileSystemCache` hands a PAGES entry back without headers; seeding\n    // `initialHeaders` would label its JSON data responses text/html.\n    expect(hello.value.headers).toBeUndefined();\n  });\n\n  it(\"seeds a dynamic route's template under its own key, with the PPR shell's postponed state\", async () => {\n    // With PPR the template is the route's fallback shell, looked up under the\n    // literal template key; the Pages Router looks up an ISR fallback the same\n    // way. Unseeded, every such lookup missed and the shell rendered per request.\n    const ctx = context([\n      await prerender(\"/isr/[id]\", \"/isr/[id]\", \"<html>shell</html>\", {\n        initialStatus: 200,\n        postponedState: \"postponed-state\",\n      }),\n      await prerender(\"/isr/[id].rsc\", \"/isr/[id]\", \"flight\"),\n      await prerender(\"/blog/[slug]\", \"/blog/[slug]\", \"<html>fallback</html>\", {\n        initialStatus: 200,\n      }),\n    ]);\n    await writeInitCache(ctx, cacheDir);\n\n    const shell = await readEntry(\"isr/[id]\");\n    expect(shell.value.kind).toBe(\"APP_PAGE\");\n    expect(shell.value.html).toBe(\"<html>shell</html>\");\n    expect(shell.value.postponed).toBe(\"postponed-state\");\n\n    const fallback = await readEntry(\"blog/[slug]\");\n    expect(fallback.value.kind).toBe(\"PAGES\");\n    expect(fallback.value.html).toBe(\"<html>fallback</html>\");\n  });\n\n  it(\"skips a Pages Router route prerendered with a non-200 status\", async () => {\n    // A build-time `notFound: true`: seeding it would be a 200 HIT with the 404\n    // page's HTML.\n    const ctx = context([\n      await prerender(\"/gone\", \"/gone\", \"<html>404</html>\", {\n        initialStatus: 404,\n      }),\n    ]);\n    await writeInitCache(ctx, cacheDir);\n    expect(existsSync(join(cacheDir, \"gone.json\"))).toBe(false);\n  });\n\n  it(\"maps each tag to the keys carrying it, under basePath-less keys\", async () => {\n    const ctx = context(\n      [\n        await prerender(\"/docs/shop\", \"/shop\", \"<html>a</html>\", {\n          initialHeaders: { \"x-next-cache-tags\": \"products,_N_T_/shop\" },\n        }),\n      ],\n      \"/docs\",\n    );\n    await writeInitCache(ctx, cacheDir);\n\n    const manifest = JSON.parse(\n      await readFile(join(cacheDir, INIT_CACHE_TAG_MANIFEST), \"utf8\"),\n    );\n    expect(manifest).toEqual({\n      products: [\"shop\"],\n      \"_N_T_/shop\": [\"shop\"],\n    });\n  });\n\n  it(\"writes no tag manifest when nothing is tagged\", async () => {\n    const ctx = context([await prerender(\"/feed.xml\", \"/feed.xml\", \"<rss/>\")]);\n    await writeInitCache(ctx, cacheDir);\n    expect(await readdir(cacheDir)).toEqual([\"feed.xml.json\"]);\n  });\n});\n"]}

package/lib/adapter/local-file-cache-handler.d.ts

@@ -1,3 +1,4 @@
+import { CacheHandlerValue } from "next/dist/server/lib/incremental-cache";
 import type { IncrementalCacheValue } from "next/dist/server/response-cache";
 /**
  * Local file cache handler that writes cache entries during Next.js build
@@ -5,12 +6,34 @@ import type { IncrementalCacheValue } from "next/dist/server/response-cache";
  */
 export declare class LocalFileCacheHandler {
     private cacheDir;
+    /** What this process has written or read back; see {@link get}. */
+    private entries;
     constructor();
     /**
      * Build file path for cache entry
      * Structure: {cacheKey}.json (BucketDeployment will add buildId prefix)
      */
     private buildFilePath;
+    /**
+     * Read back an entry this build already wrote.
+     *
+     * Required, not an optimization. Under `cacheComponents` a prerender runs
+     * twice: a first pass that fills caches (every `fetch` misses, runs for real,
+     * and is `set`), then a final pass in which every await must settle in a
+     * microtask — anything still pending is by definition "runtime data", and
+     * Next.js aborts the page with `Route "/": Next.js encountered uncached or
+     * runtime data during prerendering`. The final pass only settles immediately
+     * if `get` returns what the first pass `set`, so a write-only build-time
+     * handler makes `fetch(url, { cache: 'force-cache' })` unprerenderable and
+     * fails the build. Next.js's own `FileSystemCache` reads back for exactly
+     * this reason. Measured against next.js's
+     * `test/e2e/app-dir/resume-data-cache`, which is unbuildable without it.
+     *
+     * Entries are read through a process-local map because the two passes are the
+     * same process, and because the deserialized value is what Next.js compares
+     * by reference when deduping within a render.
+     */
+    get(cacheKey: string): Promise<CacheHandlerValue | null>;
     /**
      * Write cache entry to local file
      */

package/lib/adapter/local-file-cache-handler.js

@@ -23,6 +23,8 @@ const debug = (0, debug_1.default)("cdk-nextjs:cache-handler:local-file");
  */
 class LocalFileCacheHandler {
     cacheDir;
+    /** What this process has written or read back; see {@link get}. */
+    entries = new Map();
     constructor() {
         // Read cache directory from environment variable set by NextjsBuild
         // Falls back to default location for backward compatibility
@@ -41,6 +43,52 @@ class LocalFileCacheHandler {
         const filePath = (0, path_1.join)(this.cacheDir, `${cacheKey}.json`);
         return filePath;
     }
+    /**
+     * Read back an entry this build already wrote.
+     *
+     * Required, not an optimization. Under `cacheComponents` a prerender runs
+     * twice: a first pass that fills caches (every `fetch` misses, runs for real,
+     * and is `set`), then a final pass in which every await must settle in a
+     * microtask — anything still pending is by definition "runtime data", and
+     * Next.js aborts the page with `Route "/": Next.js encountered uncached or
+     * runtime data during prerendering`. The final pass only settles immediately
+     * if `get` returns what the first pass `set`, so a write-only build-time
+     * handler makes `fetch(url, { cache: 'force-cache' })` unprerenderable and
+     * fails the build. Next.js's own `FileSystemCache` reads back for exactly
+     * this reason. Measured against next.js's
+     * `test/e2e/app-dir/resume-data-cache`, which is unbuildable without it.
+     *
+     * Entries are read through a process-local map because the two passes are the
+     * same process, and because the deserialized value is what Next.js compares
+     * by reference when deduping within a render.
+     */
+    async get(cacheKey) {
+        const memoized = this.entries.get(cacheKey);
+        if (memoized !== undefined) {
+            return memoized;
+        }
+        try {
+            const filePath = this.buildFilePath(cacheKey);
+            if (!(0, fs_1.existsSync)(filePath)) {
+                return null;
+            }
+            // `tags` is stored alongside, not inside, the `CacheHandlerValue`; it is
+            // only consulted for tag revalidation, which cannot happen mid-build.
+            const stored = (0, cache_utils_1.parseCacheValue)((0, fs_1.readFileSync)(filePath, "utf-8"));
+            const entry = {
+                lastModified: stored.lastModified,
+                value: stored.value,
+            };
+            this.entries.set(cacheKey, entry);
+            debug(`LOCAL FILE CACHE HIT: ${cacheKey}`);
+            return entry;
+        }
+        catch (error) {
+            console.error(`Error reading local cache file for ${cacheKey}:`, error);
+            // Don't throw - a miss only costs the build a re-fetch.
+            return null;
+        }
+    }
     /**
      * Write cache entry to local file
      */
@@ -69,6 +117,9 @@ class LocalFileCacheHandler {
             const jsonString = (0, cache_utils_1.serializeCacheValue)(storageValue);
             // Write to file
             (0, fs_1.writeFileSync)(filePath, jsonString, "utf-8");
+            // Serve the rest of this build from memory rather than re-reading; see
+            // {@link get}.
+            this.entries.set(cacheKey, cacheHandlerValue);
             debug(`LOCAL FILE CACHE WRITE: ${cacheKey} -> ${filePath}`);
         }
         catch (error) {
@@ -84,4 +135,4 @@ class LocalFileCacheHandler {
     }
 }
 exports.LocalFileCacheHandler = LocalFileCacheHandler;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-file-cache-handler.js","sourceRoot":"","sources":["../../src/adapter/local-file-cache-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n  Local File Cache Handler for Next.js build-time pre-caching\n  \n  Writes cache entries to .next/cdk-nextjs-cache-handler/{cacheKey}.json\n  during the build process so they can be deployed to S3 via BucketDeployment.\n  BucketDeployment will add the buildId prefix when uploading to S3.\n*/\n/* eslint-disable import/no-extraneous-dependencies */\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from \"fs\";\nimport { dirname, join } from \"path\";\nimport getDebug from \"debug\";\nimport { CacheHandlerValue } from \"next/dist/server/lib/incremental-cache\";\nimport type { IncrementalCacheValue } from \"next/dist/server/response-cache\";\nimport { parseCacheValue, serializeCacheValue } from \"./cache-utils\";\n\nconst debug = getDebug(\"cdk-nextjs:cache-handler:local-file\");\n\n/**\n * Local file cache handler that writes cache entries during Next.js build\n * to be deployed to S3 later via BucketDeployment\n */\nexport class LocalFileCacheHandler {\n  private cacheDir: string;\n  /** What this process has written or read back; see {@link get}. */\n  private entries = new Map<string, CacheHandlerValue>();\n\n  constructor() {\n    // Read cache directory from environment variable set by NextjsBuild\n    // Falls back to default location for backward compatibility\n    this.cacheDir = process.env.CDK_NEXTJS_INIT_CACHE_DIR\n      ? process.env.CDK_NEXTJS_INIT_CACHE_DIR\n      : join(process.cwd(), \".next\", \"cdk-nextjs-init-cache\");\n\n    // Create fresh cache directory; cache directory is cleaned before each build in NextjsBuild\n    mkdirSync(this.cacheDir, { recursive: true });\n    debug(`Created local cache directory: ${this.cacheDir}`);\n  }\n\n  /**\n   * Build file path for cache entry\n   * Structure: {cacheKey}.json (BucketDeployment will add buildId prefix)\n   */\n  private buildFilePath(cacheKey: string): string {\n    const filePath = join(this.cacheDir, `${cacheKey}.json`);\n    return filePath;\n  }\n\n  /**\n   * Read back an entry this build already wrote.\n   *\n   * Required, not an optimization. Under `cacheComponents` a prerender runs\n   * twice: a first pass that fills caches (every `fetch` misses, runs for real,\n   * and is `set`), then a final pass in which every await must settle in a\n   * microtask — anything still pending is by definition \"runtime data\", and\n   * Next.js aborts the page with `Route \"/\": Next.js encountered uncached or\n   * runtime data during prerendering`. The final pass only settles immediately\n   * if `get` returns what the first pass `set`, so a write-only build-time\n   * handler makes `fetch(url, { cache: 'force-cache' })` unprerenderable and\n   * fails the build. Next.js's own `FileSystemCache` reads back for exactly\n   * this reason. Measured against next.js's\n   * `test/e2e/app-dir/resume-data-cache`, which is unbuildable without it.\n   *\n   * Entries are read through a process-local map because the two passes are the\n   * same process, and because the deserialized value is what Next.js compares\n   * by reference when deduping within a render.\n   */\n  async get(cacheKey: string): Promise<CacheHandlerValue | null> {\n    const memoized = this.entries.get(cacheKey);\n    if (memoized !== undefined) {\n      return memoized;\n    }\n    try {\n      const filePath = this.buildFilePath(cacheKey);\n      if (!existsSync(filePath)) {\n        return null;\n      }\n      // `tags` is stored alongside, not inside, the `CacheHandlerValue`; it is\n      // only consulted for tag revalidation, which cannot happen mid-build.\n      const stored = parseCacheValue(readFileSync(filePath, \"utf-8\"));\n      const entry: CacheHandlerValue = {\n        lastModified: stored.lastModified,\n        value: stored.value,\n      };\n      this.entries.set(cacheKey, entry);\n      debug(`LOCAL FILE CACHE HIT: ${cacheKey}`);\n      return entry;\n    } catch (error) {\n      console.error(`Error reading local cache file for ${cacheKey}:`, error);\n      // Don't throw - a miss only costs the build a re-fetch.\n      return null;\n    }\n  }\n\n  /**\n   * Write cache entry to local file\n   */\n  async set(\n    cacheKey: string,\n    data: IncrementalCacheValue | null,\n    tags?: string[],\n  ): Promise<void> {\n    try {\n      if (!data) {\n        return;\n      }\n\n      const filePath = this.buildFilePath(cacheKey);\n\n      // Create directory if it doesn't exist\n      const dir = dirname(filePath);\n      if (!existsSync(dir)) {\n        mkdirSync(dir, { recursive: true });\n      }\n\n      // Create CacheHandlerValue structure with tags\n      const cacheHandlerValue: CacheHandlerValue = {\n        lastModified: Date.now(),\n        value: data,\n      };\n\n      // Store with tags for revalidation checking\n      const storageValue = {\n        ...cacheHandlerValue,\n        tags: tags || [],\n      };\n\n      // Serialize to JSON with special handling for Map and Buffer\n      const jsonString = serializeCacheValue(storageValue);\n\n      // Write to file\n      writeFileSync(filePath, jsonString, \"utf-8\");\n      // Serve the rest of this build from memory rather than re-reading; see\n      // {@link get}.\n      this.entries.set(cacheKey, cacheHandlerValue);\n\n      debug(`LOCAL FILE CACHE WRITE: ${cacheKey} -> ${filePath}`);\n    } catch (error) {\n      console.error(`Error writing local cache file for ${cacheKey}:`, error);\n      // Don't throw - build should continue even if caching fails\n    }\n  }\n\n  /**\n   * Get cache directory path\n   */\n  getCacheDir(): string {\n    return this.cacheDir;\n  }\n}\n"]}