cdk-nextjs 0.6.2 → 0.7.0

package/lib/adapter/adapter.mjs

@@ -1,4 +1,4 @@
-import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import { createRequire as __cdkNextjsCreateRequire } from 'node:module'; const require = __cdkNextjsCreateRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -183,11 +183,11 @@ var require_common = __commonJS({
         let enableOverride = null;
         let namespacesCache;
         let enabledCache;
-        function debug2(...args) {
-          if (!debug2.enabled) {
+        function debug3(...args) {
+          if (!debug3.enabled) {
             return;
           }
-          const self = debug2;
+          const self = debug3;
           const curr = Number(/* @__PURE__ */ new Date());
           const ms = curr - (prevTime || curr);
           self.diff = ms;
@@ -217,12 +217,12 @@ var require_common = __commonJS({
           const logFn = self.log || createDebug.log;
           logFn.apply(self, args);
         }
-        debug2.namespace = namespace;
-        debug2.useColors = createDebug.useColors();
-        debug2.color = createDebug.selectColor(namespace);
-        debug2.extend = extend;
-        debug2.destroy = createDebug.destroy;
-        Object.defineProperty(debug2, "enabled", {
+        debug3.namespace = namespace;
+        debug3.useColors = createDebug.useColors();
+        debug3.color = createDebug.selectColor(namespace);
+        debug3.extend = extend;
+        debug3.destroy = createDebug.destroy;
+        Object.defineProperty(debug3, "enabled", {
           enumerable: true,
           configurable: false,
           get: () => {
@@ -240,9 +240,9 @@ var require_common = __commonJS({
           }
         });
         if (typeof createDebug.init === "function") {
-          createDebug.init(debug2);
+          createDebug.init(debug3);
         }
-        return debug2;
+        return debug3;
       }
       function extend(namespace, delimiter) {
         const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
@@ -761,11 +761,11 @@ var require_node = __commonJS({
     function load() {
       return process.env.DEBUG;
     }
-    function init(debug2) {
-      debug2.inspectOpts = {};
+    function init(debug3) {
+      debug3.inspectOpts = {};
       const keys = Object.keys(exports.inspectOpts);
       for (let i = 0; i < keys.length; i++) {
-        debug2.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+        debug3.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
       }
     }
     module.exports = require_common()(exports);
@@ -793,11 +793,1285 @@ var require_src = __commonJS({
 });
 
 // src/adapter/adapter.mts
-import { CachedRouteKind } from "next/dist/server/response-cache/index.js";
-import { join } from "node:path";
+import { join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { existsSync } from "node:fs";
+
+// src/adapter/build-outputs.ts
+import { existsSync, lstatSync, realpathSync } from "node:fs";
+import {
+  copyFile,
+  cp,
+  mkdir,
+  readlink,
+  rm,
+  symlink,
+  writeFile
+} from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join, relative, resolve, sep } from "node:path";
+
+// src/constants.ts
+var LOG_PREFIX = "[cdk-nextjs]";
+
+// src/runtime/manifest.ts
+var ADAPTER_MANIFEST_VERSION = 1;
+var ADAPTER_DIR_NAME = "cdk-nextjs-adapter";
+var STAGING_DIR_NAME = "app";
+var GROUPS_DIR_NAME = "groups";
+function groupStagingDirName(group) {
+  return group === void 0 ? STAGING_DIR_NAME : `${GROUPS_DIR_NAME}/${group}`;
+}
+var MANIFEST_FILE_NAME = "manifest.json";
+var STATUS_PAGE_SUFFIXES = {
+  404: ["/_not-found", "/404"],
+  500: ["/500"],
+  fallback: "/_error"
+};
+var ERROR_PAGE_SUFFIXES = [
+  ...STATUS_PAGE_SUFFIXES[404],
+  ...STATUS_PAGE_SUFFIXES[500],
+  STATUS_PAGE_SUFFIXES.fallback
+];
+var RUNTIME_DIR_NAME = "cdk-nextjs-runtime";
+
+// src/utils/base-path.ts
+function normalizeBasePath(basePath) {
+  return (basePath || "").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function hasPathPrefix(path, prefix) {
+  return !!prefix && (path === prefix || path.startsWith(`${prefix}/`));
+}
+function basePathPrefix(basePath) {
+  const bare = normalizeBasePath(basePath);
+  return bare ? `/${bare}` : "";
+}
+
+// src/adapter/function-groups.ts
+var DEFAULT_FUNCTION_GROUP = "default";
+var FUNCTION_GROUPS_ENV_VAR = "CDK_NEXTJS_FUNCTION_GROUPS";
+var ERROR_PREFIX = `${LOG_PREFIX} \`functionGroups\`: `;
+var NAME_PATTERN = /^[a-zA-Z0-9-]+$/;
+var SUBTREE_SUFFIX = "/**";
+var PATH_PATTERN_LITERAL = /[a-zA-Z0-9_\-.$/~"'@:+&]/;
+function parseFunctionGroupsEnv(value) {
+  return value ? JSON.parse(value) : void 0;
+}
+function assertNoI18nSplitting(i18n) {
+  if (i18n === null || i18n === void 0) {
+    return;
+  }
+  throw new Error(
+    `${ERROR_PREFIX}\`functionGroups\` cannot be combined with \`i18n\`. With i18n every route is locale-prefixed, so routing a group at the edge would need one CloudFront behavior per locale per pattern, against a quota of 75 for the whole distribution. Deploy one function for every route (omit \`functionGroups\`), or drop \`i18n\`.`
+  );
+}
+function validateFunctionGroups(groups) {
+  if (groups.length === 0) {
+    throw new Error(
+      `${ERROR_PREFIX}\`functionGroups\` is an empty array. Omit the prop entirely to deploy one function for every route, which is the default.`
+    );
+  }
+  const seenNames = /* @__PURE__ */ new Set();
+  const patternOwner = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    if (group.name === DEFAULT_FUNCTION_GROUP) {
+      throw new Error(
+        `${ERROR_PREFIX}"${DEFAULT_FUNCTION_GROUP}" is a reserved group name: it is the implicit group every unassigned route falls into.`
+      );
+    }
+    if (!NAME_PATTERN.test(group.name)) {
+      throw new Error(
+        `${ERROR_PREFIX}Group name "${group.name}" must match ${NAME_PATTERN} \u2014 it becomes a construct id and part of a Lambda function name.`
+      );
+    }
+    if (seenNames.has(group.name)) {
+      throw new Error(
+        `${ERROR_PREFIX}Two groups are both named "${group.name}".`
+      );
+    }
+    seenNames.add(group.name);
+    if (group.routes.length === 0) {
+      throw new Error(
+        `${ERROR_PREFIX}Group "${group.name}" owns no routes. Every group is a Lambda function, so an empty one would deploy and never be reached.`
+      );
+    }
+    for (const route of group.routes) {
+      validateRoutePattern(route, group.name);
+      const owner = patternOwner.get(route);
+      if (owner !== void 0) {
+        throw new Error(
+          `${ERROR_PREFIX}Pattern "${route}" appears in both group "${owner}" and group "${group.name}". A route can only be packaged into one function. (Overlapping-but-different patterns are fine: "/api/**" in one group and "/api/reports/**" in another resolves longest-first.)`
+        );
+      }
+      patternOwner.set(route, group.name);
+    }
+  }
+}
+function validateRoutePattern(route, groupName) {
+  const where = `Group "${groupName}" pattern "${route}"`;
+  if (!route.startsWith("/")) {
+    throw new Error(
+      `${ERROR_PREFIX}${where} must start with "/". Patterns are URL paths as the browser requests them.`
+    );
+  }
+  if (route === "/") {
+    throw new Error(
+      `${ERROR_PREFIX}${where} cannot be routed. CloudFront has no path pattern that matches only "/" \u2014 the default behavior serves it \u2014 so the home page always belongs to the "${DEFAULT_FUNCTION_GROUP}" group. Group the routes around it instead.`
+    );
+  }
+  if (route === "/_next" || route.startsWith("/_next/")) {
+    throw new Error(
+      `${ERROR_PREFIX}${where} is under "/_next", which Next.js reserves for build assets, image optimization and data routes. A Pages Router page's "/_next/data/\u2026" route follows the page into its group, so group the page itself instead.`
+    );
+  }
+  if (route === SUBTREE_SUFFIX) {
+    throw new Error(
+      `${ERROR_PREFIX}${where} would own every route, leaving the default group empty. Splitting exists to divide routes between functions; omit \`functionGroups\` to deploy them all in one.`
+    );
+  }
+  if (/[[\]]/.test(route)) {
+    throw new Error(
+      `${ERROR_PREFIX}${where} contains a dynamic segment. Patterns become CloudFront behavior path patterns, which support only "*" and "?", so "${route}" could only deploy as a wildcard that also captures its siblings. Use a subtree instead: "/blog/**" owns "/blog/[slug]".`
+    );
+  }
+  if (/\((.*)\)/.test(route)) {
+    throw new Error(
+      `${ERROR_PREFIX}${where} contains a route group segment. Route groups like "(marketing)" organize files and never appear in a URL, so they cannot be routed on. Use the URL path the route is served at.`
+    );
+  }
+  const withoutSubtree = route.endsWith(SUBTREE_SUFFIX) ? route.slice(0, -SUBTREE_SUFFIX.length) : route;
+  if (/[*?]/.test(withoutSubtree)) {
+    throw new Error(
+      `${ERROR_PREFIX}${where} contains a wildcard somewhere other than a trailing "/**". The only two forms are an exact path ("/pricing") and a subtree ("/api/reports/**").`
+    );
+  }
+  if (route.includes("//")) {
+    throw new Error(`${ERROR_PREFIX}${where} contains an empty path segment.`);
+  }
+  const invalid = [...new Set(withoutSubtree)].filter(
+    (char) => !PATH_PATTERN_LITERAL.test(char)
+  );
+  if (invalid.length > 0) {
+    throw new Error(
+      `${ERROR_PREFIX}${where} contains ${invalid.map((char) => JSON.stringify(char)).join(", ")}, which a CloudFront behavior path pattern cannot contain (allowed: A-Z a-z 0-9 _ - . $ / ~ " ' @ : + &). Escaping it with "?" would also match other routes of the same length. Use a subtree on a parent segment whose name is plain ASCII instead: "/intl/**" owns "/intl/\xFCber".`
+    );
+  }
+}
+function assignRoutesToGroups(groups, entries, options) {
+  validateFunctionGroups(groups);
+  const basePath = basePathPrefix(options.basePath);
+  const edgeBase = {
+    basePath,
+    buildId: options.buildId,
+    trailingSlash: options.trailingSlash ?? false
+  };
+  const patterns = edgeBehaviors(
+    groups,
+    {},
+    { ...edgeBase, dataRouteGroups: /* @__PURE__ */ new Set() }
+  );
+  const matchedPatterns = /* @__PURE__ */ new Set();
+  const groupOfEntrypoint = /* @__PURE__ */ new Map();
+  const winningIndexOfEntrypoint = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    let winner;
+    for (const [index, pattern] of patterns.entries()) {
+      if (!pattern.regex.test(entry.template)) {
+        continue;
+      }
+      matchedPatterns.add(`${pattern.group}\0${pattern.route}`);
+      winner ??= index;
+    }
+    if (winner === void 0 || isInterceptionTemplate(entry.template)) {
+      continue;
+    }
+    const incumbent = winningIndexOfEntrypoint.get(entry.entrypointId);
+    if (incumbent === void 0 || winner < incumbent) {
+      winningIndexOfEntrypoint.set(entry.entrypointId, winner);
+      groupOfEntrypoint.set(entry.entrypointId, patterns[winner].group);
+    }
+  }
+  for (const group of groups) {
+    for (const route of group.routes) {
+      if (!matchedPatterns.has(`${group.name}\0${route}`)) {
+        throw new Error(
+          `${ERROR_PREFIX}Group "${group.name}" pattern "${route}" matches no route in this build. ` + optionalCatchAllParentHint(route, entries, basePath) + `Patterns match route templates as Next.js declares them (e.g. "/blog/[slug]" is matched by "/blog/**"), and prerendered pages and static assets are served from S3 and need no group.`
+        );
+      }
+    }
+  }
+  const edge = {
+    ...edgeBase,
+    // Only a group that owns a Pages Router page has data URLs to route. Read
+    // before interception moves files: those are App Router, never pages.
+    dataRouteGroups: new Set(
+      entries.filter((entry) => entry.type === "page").map(
+        (entry) => groupOfEntrypoint.get(entry.entrypointId) ?? DEFAULT_FUNCTION_GROUP
+      )
+    )
+  };
+  reassignInterceptingFiles(
+    entries,
+    groupOfEntrypoint,
+    edgeBehaviors(
+      groups,
+      templatesByGroup(groups, entries, groupOfEntrypoint),
+      edge
+    ),
+    edge
+  );
+  const assigned = templatesByGroup(groups, entries, groupOfEntrypoint);
+  const behaviors = edgeBehaviors(groups, assigned, edge);
+  const router = {
+    fileOfTemplate: fileOfTemplate(entries),
+    routing: options.routing
+  };
+  assertEdgeReachesEveryFile(
+    entries,
+    groupOfEntrypoint,
+    behaviors,
+    edge,
+    router
+  );
+  assertRewritesStayInGroup(groupOfEntrypoint, behaviors, router);
+  for (const key of Object.keys(assigned)) {
+    assigned[key] = [...assigned[key]].sort();
+  }
+  return {
+    templates: assigned,
+    behaviors: behaviors.map(({ group, route, pattern }) => ({
+      group,
+      route,
+      pattern
+    }))
+  };
+}
+function routedPatterns(routes, ownedTemplates, basePath) {
+  const result = [...routes];
+  for (const route of routes) {
+    if (!route.endsWith(SUBTREE_SUFFIX)) {
+      continue;
+    }
+    const parent = route.slice(0, -SUBTREE_SUFFIX.length);
+    const prefix = `${prefixBasePath(parent, basePath)}/`;
+    const ownsOptionalCatchAll = ownedTemplates.some(
+      (template) => template.startsWith(prefix) && OPTIONAL_CATCH_ALL_SEGMENT.test(template.slice(prefix.length))
+    );
+    if (ownsOptionalCatchAll && !result.includes(parent)) {
+      result.push(parent);
+    }
+  }
+  return result;
+}
+function pathPatternsFor(route, options) {
+  const isSubtree = route.endsWith(SUBTREE_SUFFIX);
+  const base = isSubtree ? route.slice(0, -SUBTREE_SUFFIX.length) : route;
+  const bare = base.replace(/^\//, "");
+  const patterns = [isSubtree ? `${bare}/*` : bare];
+  if (!isSubtree && options.trailingSlash && bare) {
+    patterns.push(`${bare}/`);
+  }
+  if (options.hasDataRoutes) {
+    patterns.push(
+      isSubtree ? `_next/data/${dataBuildId(options.buildId)}/${bare}/*` : `_next/data/${dataBuildId(options.buildId)}/${bare}.json`
+    );
+  }
+  return patterns;
+}
+function behaviorSpecificity(pattern) {
+  const segments = pattern.split("/").filter(Boolean);
+  const firstWildcard = segments.findIndex((segment) => segment.includes("*"));
+  const literalDepth = firstWildcard === -1 ? segments.length : firstWildcard;
+  const exact = firstWildcard === -1 ? 1 : 0;
+  return (literalDepth * 2 + exact) * 1e6 + segments.length * 1e4 + pattern.length;
+}
+function dataBuildId(buildId) {
+  if (!buildId) {
+    throw new Error(
+      `${ERROR_PREFIX}Routing a Pages Router app's "/_next/data/<buildId>/\u2026" URLs needs its build ID, and none was passed. This is a cdk-nextjs bug: the build ID comes from the adapter manifest.`
+    );
+  }
+  const invalid = [...new Set(buildId)].filter(
+    (char) => !PATH_PATTERN_LITERAL.test(char) || char === "/"
+  );
+  if (invalid.length > 0) {
+    throw new Error(
+      `${ERROR_PREFIX}The build ID "${buildId}" contains ${invalid.map((char) => JSON.stringify(char)).join(", ")}, which a CloudFront path pattern cannot hold, so its "/_next/data" URLs cannot be routed to a group. Make \`generateBuildId\` return only A-Z a-z 0-9 _ - . characters.`
+    );
+  }
+  return buildId;
+}
+function optionalCatchAllParentHint(route, entries, basePath) {
+  if (route.endsWith(SUBTREE_SUFFIX)) {
+    return "";
+  }
+  const prefix = `${prefixBasePath(route, basePath)}/`;
+  const catchAll = entries.find(
+    (entry) => entry.template.startsWith(prefix) && OPTIONAL_CATCH_ALL_SEGMENT.test(entry.template.slice(prefix.length))
+  );
+  if (!catchAll) {
+    return "";
+  }
+  return `"${route}" is served by the optional catch-all "${catchAll.template}", whose subtree pattern "${route}${SUBTREE_SUFFIX}" routes "${route}" as well \u2014 use that instead. `;
+}
+var OPTIONAL_CATCH_ALL_SEGMENT = /^\[\[\.\.\.[^\]/]+\]\]$/;
+var INTERCEPTION_MARKERS = ["(..)(..)", "(.)", "(..)", "(...)"];
+function interceptionMarkerOf(path) {
+  for (const segment of path.split("/")) {
+    const marker = INTERCEPTION_MARKERS.find((it) => segment.startsWith(it));
+    if (marker) {
+      return marker;
+    }
+  }
+  return void 0;
+}
+function isInterceptionTemplate(template) {
+  return interceptionMarkerOf(template) !== void 0;
+}
+function interceptedRoute(path) {
+  const marker = interceptionMarkerOf(path);
+  if (marker === void 0) {
+    return void 0;
+  }
+  const at = path.indexOf(marker);
+  const intercepting = path.slice(0, at).split("/").filter(Boolean);
+  const rest = path.slice(at + marker.length).split("/").filter(Boolean);
+  const parent = marker === "(.)" ? intercepting : marker === "(..)" ? intercepting.slice(0, -1) : marker === "(..)(..)" ? intercepting.slice(0, -2) : [];
+  return `/${[...parent, ...rest].join("/")}`;
+}
+function isInternalTemplate(path) {
+  return path.endsWith(".rsc") || path.includes(".segments/");
+}
+function edgeBehaviors(groups, assigned, edge) {
+  return groups.flatMap(
+    (group) => routedPatterns(
+      group.routes,
+      assigned[group.name] ?? [],
+      edge.basePath
+    ).flatMap(
+      (route) => pathPatternsFor(route, {
+        trailingSlash: edge.trailingSlash,
+        buildId: edge.buildId,
+        hasDataRoutes: edge.dataRouteGroups.has(group.name)
+      }).map((pattern) => ({
+        group: group.name,
+        route,
+        pattern,
+        regex: cloudFrontPatternRegex(`${edge.basePath}/${pattern}`)
+      }))
+    )
+  ).sort(
+    (a, b) => behaviorSpecificity(b.pattern) - behaviorSpecificity(a.pattern)
+  );
+}
+function cloudFrontPatternRegex(pattern) {
+  const source = [...pattern].map(
+    (char) => char === "*" ? ".*" : char === "?" ? "." : char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  ).join("");
+  return new RegExp(`^${source}$`);
+}
+function edgeBehaviorFor(behaviors, url) {
+  return behaviors.find((behavior) => behavior.regex.test(url));
+}
+function templatesByGroup(groups, entries, groupOfEntrypoint) {
+  const assigned = {
+    [DEFAULT_FUNCTION_GROUP]: []
+  };
+  for (const group of groups) {
+    assigned[group.name] = [];
+  }
+  for (const entry of entries) {
+    const group = groupOfEntrypoint.get(entry.entrypointId) ?? DEFAULT_FUNCTION_GROUP;
+    assigned[group].push(entry.template);
+  }
+  return assigned;
+}
+function reassignInterceptingFiles(entries, groupOfEntrypoint, behaviors, edge) {
+  for (const entry of entries) {
+    const path = stripBasePath(entry.template, edge.basePath);
+    if (path === void 0 || isInternalTemplate(path)) {
+      continue;
+    }
+    const target = interceptedRoute(path);
+    if (target === void 0) {
+      continue;
+    }
+    const url = withBasePath(target, edge.basePath);
+    const group = edgeBehaviorFor(behaviors, url)?.group ?? DEFAULT_FUNCTION_GROUP;
+    const intercepted = templateRegex(url);
+    const split = behaviors.find(
+      (behavior) => behavior.group !== group && !behavior.pattern.startsWith("_next/data/") && sampleUrl(behavior.route, edge.basePath).some(
+        (it) => intercepted.test(it)
+      )
+    );
+    if (split) {
+      throw new Error(
+        `${ERROR_PREFIX}"${entry.entrypointId}" is the interception route "${entry.template}", which Next.js reaches by rewriting a request for "${url}" inside whichever function CloudFront sent it to \u2014 so it is packaged with the group that owns "${url}". That URL space is split, though: most of it reaches ${groupLabel(group)}, but group "${split.group}"'s pattern "${split.route}" claims part of it, and one file cannot be in both. Route all of "${target}" to one group.`
+      );
+    }
+    groupOfEntrypoint.set(entry.entrypointId, group);
+  }
+}
+function sampleUrl(route, basePath) {
+  return route.endsWith(SUBTREE_SUFFIX) ? [`${basePath}${route.slice(0, -SUBTREE_SUFFIX.length)}/_`] : [`${basePath}${route}`];
+}
+function templateRegex(template) {
+  const source = template.split("/").filter(Boolean).map(
+    (segment) => [
+      `/${segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`,
+      "/[^/]+",
+      "/.+",
+      "(?:/.+)?"
+    ][segmentKind(segment)]
+  ).join("");
+  return new RegExp(`^${source || "/"}$`);
+}
+function assertEdgeReachesEveryFile(entries, groupOfEntrypoint, behaviors, edge, router) {
+  const files = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const list = files.get(entry.entrypointId) ?? [];
+    list.push(entry);
+    files.set(entry.entrypointId, list);
+  }
+  const deepest = Math.max(
+    0,
+    ...entries.map((entry) => {
+      const path = stripBasePath(entry.template, edge.basePath);
+      return path !== void 0 && isRoutablePath(path) ? path.split("/").filter(Boolean).length : 0;
+    })
+  ) + 1;
+  for (const [file, fileEntries] of files) {
+    const owner = groupOfEntrypoint.get(file) ?? DEFAULT_FUNCTION_GROUP;
+    const misrouted = [];
+    for (const entry of fileEntries) {
+      for (const url of servedUrls(entry.template, entry.type, edge)) {
+        const behavior = edgeBehaviorFor(behaviors, url);
+        const group = behavior?.group ?? DEFAULT_FUNCTION_GROUP;
+        if (group !== owner && !misrouted.some((it) => it.url === url)) {
+          misrouted.push({ url, group, route: behavior?.route });
+        }
+      }
+      for (const it of capturedDynamicUrls(
+        entry,
+        owner,
+        deepest,
+        behaviors,
+        edge,
+        router
+      )) {
+        if (!misrouted.some((known) => known.url === it.url)) {
+          misrouted.push(it);
+        }
+      }
+    }
+    if (misrouted.length > 0) {
+      throw new Error(misroutedFileMessage(file, owner, misrouted, edge));
+    }
+  }
+}
+var ANY_SEGMENT = "_";
+function isRoutablePath(path) {
+  return !isInternalTemplate(path) && !isInterceptionTemplate(path) && !path.startsWith("/_next/data/");
+}
+function segmentKind(segment) {
+  if (OPTIONAL_CATCH_ALL_SEGMENT.test(segment)) {
+    return 3;
+  }
+  if (/^\[\.\.\.[^\]]+\]$/.test(segment)) {
+    return 2;
+  }
+  return /^\[[^\]]+\]$/.test(segment) ? 1 : 0;
+}
+function capturedDynamicUrls(entry, owner, deepest, behaviors, edge, router) {
+  const path = stripBasePath(entry.template, edge.basePath);
+  if (path === void 0 || !path.includes("[") || ERROR_PAGE_SUFFIXES.includes(path) || !isRoutablePath(path)) {
+    return [];
+  }
+  const segments = path.split("/").filter(Boolean);
+  const samples = /* @__PURE__ */ new Set();
+  for (const behavior of behaviors) {
+    if (behavior.group === owner || behavior.pattern.startsWith("_next/data/")) {
+      continue;
+    }
+    const bare = behavior.pattern.replace(/\/$/, "");
+    const isSubtree = bare.endsWith("/*");
+    const prefix = (isSubtree ? bare.slice(0, -2) : bare).split("/").filter(Boolean);
+    for (const sample of sampleTemplatePaths(
+      segments,
+      prefix,
+      isSubtree,
+      Math.max(deepest, prefix.length + 1)
+    )) {
+      samples.add(sample);
+    }
+  }
+  const misrouted = [];
+  const check = (url, resolved) => {
+    const behavior = edgeBehaviorFor(behaviors, url);
+    const group = behavior?.group ?? DEFAULT_FUNCTION_GROUP;
+    if (group === owner || misrouted.some((it) => it.url === url)) {
+      return;
+    }
+    if (resolveFile(resolved, router) === entry.entrypointId) {
+      misrouted.push({
+        url,
+        group,
+        route: behavior?.route,
+        servedAs: entry.template
+      });
+    }
+  };
+  for (const sample of samples) {
+    for (const { url, resolved } of urlVariants(sample, entry.type, edge)) {
+      check(url, resolved);
+    }
+  }
+  return misrouted;
+}
+function sampleTemplatePaths(template, prefix, isSubtree, maxDepth) {
+  if (!isSubtree) {
+    const path = `/${prefix.join("/")}`;
+    return templateRegex(`/${template.join("/")}`).test(path) ? [path] : [];
+  }
+  const valueAt = (at) => at < prefix.length ? prefix[at] : ANY_SEGMENT;
+  const results = [];
+  const walk = (index, acc) => {
+    if (index === template.length) {
+      if (acc.length >= prefix.length) {
+        results.push(`/${acc.join("/")}`);
+      }
+      return;
+    }
+    const segment = template[index];
+    const at = acc.length;
+    const kind = segmentKind(segment);
+    if (kind === 0) {
+      if (at >= prefix.length || prefix[at] === segment) {
+        walk(index + 1, [...acc, segment]);
+      }
+      return;
+    }
+    if (kind === 1) {
+      walk(index + 1, [...acc, valueAt(at)]);
+      return;
+    }
+    for (let count = kind === 2 ? 1 : 0; at + count <= maxDepth; count++) {
+      const taken = Array.from({ length: count }, (_, i) => valueAt(at + i));
+      walk(index + 1, [...acc, ...taken]);
+    }
+  };
+  walk(0, []);
+  return results;
+}
+function servedUrls(template, type, edge) {
+  const path = stripBasePath(template, edge.basePath);
+  if (path === void 0 || ERROR_PAGE_SUFFIXES.includes(path) || isInternalTemplate(path) || isInterceptionTemplate(path)) {
+    return [];
+  }
+  if (path.startsWith("/_next/data/")) {
+    return [template];
+  }
+  const paths = [path];
+  const optional = /^(.*)\/(\[\[\.\.\.[^\]/]+\]\])$/.exec(path);
+  if (optional) {
+    paths.push(optional[1] || "/");
+  }
+  return paths.flatMap(
+    (it) => urlVariants(it, type, edge).map(({ url }) => url)
+  );
+}
+function urlVariants(path, type, edge) {
+  const url = withBasePath(path, edge.basePath);
+  const variants = [{ url, resolved: url }];
+  if (edge.trailingSlash && path !== "/") {
+    variants.push({ url: `${url}/`, resolved: url });
+  }
+  if (type === "page" && edge.buildId) {
+    const data = `${edge.basePath}/_next/data/${edge.buildId}${path === "/" ? "/index" : path}.json`;
+    variants.push({ url: data, resolved: data });
+  }
+  return variants;
+}
+function misroutedFileMessage(file, owner, misrouted, edge) {
+  const where = misrouted.map(
+    (it) => `"${it.url}" to ${groupLabel(it.group)}` + (it.route ? ` (its pattern "${it.route}")` : "")
+  ).join(", ");
+  const head = `${ERROR_PREFIX}"${file}" is packaged into ${groupLabel(owner)}, but CloudFront would send ${where}, whose function does not have it: a 404 on every such request. Every URL one file serves has to reach the group that holds the file.`;
+  const captured = misrouted.filter((it) => it.servedAs !== void 0);
+  if (captured.length > 0) {
+    const templates = [...new Set(captured.map((it) => `"${it.servedAs}"`))];
+    return `${head} Those URLs are part of the dynamic route ${templates.join(", ")} ("${ANY_SEGMENT}" stands for any segment value): the pattern captures them at the edge, and no route packaged into the capturing group is more specific, so Next.js still resolves them to this file. Give that group a route that answers them (a catch-all under its pattern, say), or narrow the pattern.`;
+  }
+  if (owner === DEFAULT_FUNCTION_GROUP) {
+    return `${head} A pattern claims a URL of a file that no pattern moved: narrow it, or give the group the file's other routes too.`;
+  }
+  const unroutable = misrouted.filter(
+    (it) => suggestedPattern(it.url, edge) === void 0
+  );
+  if (unroutable.length > 0) {
+    return `${head} ${unroutable.map((it) => `"${it.url}"`).join(", ")} cannot be routed to any group \u2014 CloudFront has no pattern for the home page alone, and a dynamic first segment would need "/**" \u2014 so this file can only be served by the "${DEFAULT_FUNCTION_GROUP}" group. Remove the pattern that moved it. (A Pages Router home page is also "/index": one file.)`;
+  }
+  const suggestions = [
+    ...new Set(misrouted.map((it) => suggestedPattern(it.url, edge)))
+  ];
+  return `${head} Add ${suggestions.map((it) => `"${it}"`).join(", ")} to group "${owner}"'s routes.`;
+}
+function suggestedPattern(url, edge) {
+  let path = stripBasePath(url, edge.basePath) ?? url;
+  const dataPrefix = `/_next/data/${edge.buildId}/`;
+  if (path.startsWith(dataPrefix) && path.endsWith(".json")) {
+    path = `/${path.slice(dataPrefix.length, -".json".length)}`;
+    path = path === "/index" ? "/" : path;
+  }
+  if (path.length > 1 && path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  const segments = path.split("/").filter(Boolean);
+  const firstDynamic = segments.findIndex((segment) => segment.startsWith("["));
+  if (segments.length === 0 || firstDynamic === 0) {
+    return void 0;
+  }
+  return firstDynamic === -1 ? path : `/${segments.slice(0, firstDynamic).join("/")}${SUBTREE_SUFFIX}`;
+}
+function assertRewritesStayInGroup(groupOfEntrypoint, behaviors, router) {
+  const { routing } = router;
+  const phases = [
+    [routing.beforeFiles, false],
+    // `afterFiles` and `fallback` only apply when no file matched the URL, so a
+    // source that is itself a route never reaches the destination.
+    [routing.afterFiles, true],
+    [routing.fallback, true]
+  ];
+  for (const [rules, yieldsToFiles] of phases) {
+    for (const rule of rules ?? []) {
+      const destination = literalDestination(rule.destination);
+      if (destination === void 0 || isInterceptionTemplate(destination)) {
+        continue;
+      }
+      const file = resolveFile(destination, router);
+      if (file === void 0) {
+        continue;
+      }
+      const target = groupOfEntrypoint.get(file) ?? DEFAULT_FUNCTION_GROUP;
+      for (const url of rewriteSourceUrls(rule.source)) {
+        if (yieldsToFiles && router.fileOfTemplate.has(url)) {
+          continue;
+        }
+        const behavior = edgeBehaviorFor(behaviors, url);
+        const group = behavior?.group ?? DEFAULT_FUNCTION_GROUP;
+        if (group === target) {
+          continue;
+        }
+        throw new Error(
+          `${ERROR_PREFIX}The next.config rewrite from "${rule.source}" to "${rule.destination}" crosses groups: CloudFront sends "${url}" to ${groupLabel(group)}` + (behavior ? ` (its pattern "${behavior.route}")` : "") + `, and Next.js then serves it with "${file}", which is packaged into ${groupLabel(target)}. A rewrite is applied inside the function that received the request, so its source and its destination have to be routed to the same group.`
+        );
+      }
+    }
+  }
+}
+function literalDestination(destination) {
+  if (!destination?.startsWith("/")) {
+    return void 0;
+  }
+  const pathname = destination.split(/[?#]/)[0];
+  if (/[$:]/.test(pathname)) {
+    return void 0;
+  }
+  return pathname.length > 1 ? pathname.replace(/\/$/, "") : pathname;
+}
+function fileOfTemplate(entries) {
+  return new Map(
+    entries.filter((entry) => !isInternalTemplate(entry.template)).map((entry) => [entry.template, entry.entrypointId])
+  );
+}
+function resolveFile(pathname, { fileOfTemplate: files, routing }) {
+  const exact = files.get(pathname);
+  if (exact !== void 0) {
+    return exact;
+  }
+  for (const route of routing.dynamicRoutes ?? []) {
+    if (new RegExp(route.sourceRegex, "i").test(pathname)) {
+      const template = route.destination?.split("?")[0];
+      return template === void 0 ? void 0 : files.get(template);
+    }
+  }
+  return void 0;
+}
+function rewriteSourceUrls(source) {
+  if (!source?.startsWith("/")) {
+    return [];
+  }
+  const segments = [];
+  let optionalFrom;
+  for (const segment of source.split("/").slice(1)) {
+    if (!/[:()*?+{}[\]]/.test(segment)) {
+      segments.push(segment);
+      continue;
+    }
+    optionalFrom = /^:\w+[*?]$/.test(segment) ? segments.length : void 0;
+    segments.push(`[${/:(\w+)/.exec(segment)?.[1] ?? "param"}]`);
+  }
+  const urls = [`/${segments.join("/")}`];
+  if (optionalFrom !== void 0) {
+    urls.push(`/${segments.slice(0, optionalFrom).join("/")}`);
+  }
+  return urls;
+}
+function groupLabel(group) {
+  return group === DEFAULT_FUNCTION_GROUP ? `the "${DEFAULT_FUNCTION_GROUP}" group` : `group "${group}"`;
+}
+function prefixBasePath(route, basePath) {
+  return `${basePathPrefix(basePath)}${route}`;
+}
+function stripBasePath(template, basePath) {
+  if (!basePath) {
+    return template;
+  }
+  return hasPathPrefix(template, basePath) ? template.slice(basePath.length) || "/" : void 0;
+}
+function withBasePath(path, basePath) {
+  return path === "/" ? basePath || "/" : `${basePath}${path}`;
+}
+
+// src/adapter/build-outputs.ts
+var ENV_FILES = [".env", ".env.production"];
+var RUNTIME_NEXT_MODULES = ["next/dist/server/serve-static.js"];
+var IMAGE_NEXT_MODULES = [
+  "next/dist/server/config-shared.js",
+  "next/dist/shared/lib/image-config.js",
+  "next/dist/server/image-optimizer.js"
+];
+var NEXT_FILE_TRACER = "next/dist/compiled/@vercel/nft";
+async function writeBuildOutputs(ctx, options = {}) {
+  const adapterDir = join(ctx.distDir, ADAPTER_DIR_NAME);
+  const manifestPath = join(adapterDir, MANIFEST_FILE_NAME);
+  const { manifest, groups } = buildAdapterManifest(ctx, options);
+  const runtimeClosure = /* @__PURE__ */ new Map();
+  const imageClosure = /* @__PURE__ */ new Map();
+  await addRuntimeNextClosure(ctx, runtimeClosure, imageClosure);
+  addRequiredServerFiles(ctx, runtimeClosure);
+  await rm(adapterDir, { recursive: true, force: true });
+  const stagedGroups = [];
+  for (const group of groups) {
+    const groupStaging = merged(
+      merged(group.staging, runtimeClosure),
+      group.name === DEFAULT_FUNCTION_GROUP ? imageClosure : /* @__PURE__ */ new Map()
+    );
+    const path = join(adapterDir, ...group.dirName.split("/"));
+    await mkdir(path, { recursive: true });
+    await stageFiles(groupStaging, path);
+    stagedGroups.push({ name: group.name, path, fileCount: groupStaging.size });
+  }
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  return {
+    manifest,
+    groups,
+    adapterDir,
+    manifestPath,
+    stagedGroups
+  };
+}
+function merged(base, additions) {
+  const result = new Map(base);
+  for (const [key, source] of additions) {
+    if (!result.has(key)) {
+      result.set(key, source);
+    }
+  }
+  return result;
+}
+function buildAdapterManifest(ctx, options = {}) {
+  const { outputs, repoRoot } = ctx;
+  const basePath = ctx.config.basePath || "";
+  assertBuildCwd(ctx, options.buildCwd ?? process.cwd());
+  const invocable = [
+    ...outputs.pages,
+    ...outputs.pagesApi,
+    ...outputs.appPages,
+    ...outputs.appRoutes,
+    ...outputs.middleware ? [outputs.middleware] : []
+  ];
+  assertNodeRuntimes(invocable, outputs.middleware);
+  warnOnDroppedRouteConfig(invocable);
+  const staticFiles = collectStaticFiles(ctx);
+  const entrypoints = {};
+  for (const { outputs: group, type } of [
+    { outputs: outputs.pages, type: "page" },
+    { outputs: outputs.pagesApi, type: "page-api" },
+    { outputs: outputs.appPages, type: "app-page" },
+    { outputs: outputs.appRoutes, type: "app-route" }
+  ]) {
+    for (const output of group) {
+      addEntrypoint(entrypoints, repoRoot, output, type, basePath);
+    }
+  }
+  addPrerenderPathnames(
+    entrypoints,
+    outputs.prerenders,
+    ctx.routing.dynamicRoutes,
+    basePath,
+    `${basePath}/_next/data/${ctx.buildId}/`
+  );
+  const pathnames = sortedUnique([
+    ...Object.keys(entrypoints),
+    ...Object.keys(staticFiles)
+  ]);
+  const functionGroups = options.functionGroups ?? parseFunctionGroupsEnv(process.env[FUNCTION_GROUPS_ENV_VAR]);
+  if (functionGroups) {
+    assertNoI18nSplitting(ctx.config.i18n ?? null);
+  }
+  const assignment = functionGroups ? assignRoutesToGroups(
+    functionGroups,
+    // Keyed on the file, not the output `id`: a Pages Router page and its
+    // `/_next/data/<buildId>/<page>.json` route are separate outputs with
+    // separate ids backed by one file, and only the page's template matches
+    // a group pattern.
+    Object.entries(entrypoints).map(([template, entrypoint]) => ({
+      template,
+      entrypointId: entrypoint.filePath,
+      type: entrypoint.type
+    })),
+    {
+      basePath: ctx.config.basePath || "",
+      buildId: ctx.buildId,
+      trailingSlash: ctx.config.trailingSlash === true,
+      routing: ctx.routing
+    }
+  ) : void 0;
+  const manifest = {
+    version: ADAPTER_MANIFEST_VERSION,
+    buildId: ctx.buildId,
+    relativeProjectDir: toPosix(relative(repoRoot, ctx.projectDir)),
+    config: {
+      basePath: ctx.config.basePath || "",
+      trailingSlash: ctx.config.trailingSlash === true,
+      assetPrefix: ctx.config.assetPrefix || "",
+      distDir: toPosix(relative(ctx.projectDir, ctx.distDir)),
+      compress: ctx.config.compress !== false,
+      generateEtags: ctx.config.generateEtags !== false,
+      i18n: ctx.config.i18n ?? null,
+      deploymentId: (ctx.config.deploymentId ?? "").replace(
+        /[^A-Za-z0-9_-]/g,
+        "-"
+      )
+    },
+    routing: ctx.routing,
+    pathnames,
+    entrypoints,
+    middleware: buildMiddleware(repoRoot, outputs.middleware),
+    staticFiles,
+    ...assignment ? {
+      groups: assignment.templates,
+      behaviors: assignment.behaviors,
+      functionGroups: functionGroups.map(({ name, routes }) => ({
+        name,
+        routes
+      }))
+    } : {}
+  };
+  const groups = assignment ? Object.entries(assignment.templates).map(([name, templates]) => ({
+    name,
+    dirName: groupStagingDirName(name),
+    staging: collectGroupStagingPlan(
+      ctx,
+      invocable,
+      entrypoints,
+      templates
+    )
+  })) : [
+    {
+      name: DEFAULT_FUNCTION_GROUP,
+      dirName: groupStagingDirName(),
+      staging: servedStagingPlan(ctx, invocable)
+    }
+  ];
+  return { manifest, groups };
+}
+function collectGroupStagingPlan(ctx, invocable, entrypoints, templates) {
+  const basePath = ctx.config.basePath || "";
+  const ownedEntrypoints = [
+    ...templates,
+    ...ERROR_PAGE_SUFFIXES.map((suffix) => `${basePath}${suffix}`)
+  ].map((template) => entrypoints[template]).filter((entry) => entry !== void 0);
+  const ownedFiles = new Set(ownedEntrypoints.map((entry) => entry.filePath));
+  const middleware = ctx.outputs.middleware;
+  const owned = invocable.filter(
+    (output) => ownedFiles.has(toPosix(relative(ctx.repoRoot, output.filePath))) || output === middleware
+  );
+  return servedStagingPlan(ctx, owned);
+}
+function servedStagingPlan(ctx, outputs) {
+  const staging = collectStagingPlan(ctx, outputs);
+  stageServedStaticFiles(ctx, staging);
+  return staging;
+}
+function assertNodeRuntimes(invocable, middleware) {
+  const offending = invocable.filter((output) => output.runtime !== "nodejs");
+  if (offending.length === 0) {
+    return;
+  }
+  const offendingMiddleware = middleware && offending.includes(middleware);
+  const routes = sortedUnique(
+    offending.filter((output) => output !== middleware).map((output) => `${output.sourcePage} (runtime: "${output.runtime}")`)
+  );
+  const reasons = [];
+  if (routes.length > 0) {
+    reasons.push(
+      `cdk-nextjs cannot deploy routes built for the edge runtime. Remove \`export const runtime = "edge"\` from:
+` + routes.map((route) => `  - ${route}`).join("\n")
+    );
+  }
+  if (offendingMiddleware) {
+    reasons.push(
+      `cdk-nextjs cannot deploy middleware built for the edge runtime (${middleware.filePath}, runtime: "${middleware.runtime}"). Rename it to \`proxy.ts\` (Next.js 16 runs proxy on the Node runtime), or keep \`middleware.ts\` and add \`export const config = { runtime: "nodejs" }\` to it \u2014 \`middleware.ts\` defaults to the edge runtime, but does not require it.`
+    );
+  }
+  throw new Error(
+    `${LOG_PREFIX} ${reasons.join("\n")}
+The edge runtime is deprecated in Next.js: https://nextjs.org/docs/messages/edge-runtime-deprecated`
+  );
+}
+function warnOnDroppedRouteConfig(invocable) {
+  const dropped = {
+    maxDuration: [],
+    preferredRegion: []
+  };
+  for (const output of invocable) {
+    if (output.config?.maxDuration !== void 0) {
+      dropped.maxDuration.push(output.sourcePage);
+    }
+    if (output.config?.preferredRegion !== void 0) {
+      dropped.preferredRegion.push(output.sourcePage);
+    }
+  }
+  const remedy = {
+    maxDuration: "Set the function timeout with the construct's `overrides` prop instead (e.g. `overrides: { nextjsFunctions: { functionProps: { timeout: Duration.seconds(30) } } }`); a Lambda timeout is per-function while `maxDuration` is per-route.",
+    preferredRegion: "Honoring it would require a multi-region deployment, which this construct does not model."
+  };
+  for (const key of ["maxDuration", "preferredRegion"]) {
+    const routes = sortedUnique(dropped[key]);
+    if (routes.length === 0) {
+      continue;
+    }
+    console.warn(
+      `${LOG_PREFIX} \`${key}\` is not honored by cdk-nextjs. ${routes.length} route(s) set it, including: ${routes.slice(0, 5).join(", ")}${routes.length > 5 ? `, and ${routes.length - 5} more` : ""}. ` + remedy[key]
+    );
+  }
+}
+function collectStagingPlan(ctx, invocable) {
+  const { repoRoot } = ctx;
+  const staging = /* @__PURE__ */ new Map();
+  const hashes = /* @__PURE__ */ new Map();
+  const add = (key, source, hash) => {
+    assertStagingKey(key, source);
+    const existingHash = hashes.get(key);
+    if (hash !== void 0 && existingHash !== void 0 && existingHash !== hash) {
+      throw new Error(
+        `${LOG_PREFIX} Two build outputs map "${key}" to different content (hashes ${existingHash} and ${hash}). One deployment package cannot hold both. This usually means two Next.js projects in the same repo write the same repo-root-relative path.`
+      );
+    }
+    if (hash !== void 0) {
+      hashes.set(key, hash);
+    }
+    if (!staging.has(key)) {
+      staging.set(key, source);
+    }
+  };
+  for (const output of invocable) {
+    for (const [key, source] of Object.entries(output.assets)) {
+      add(key, source, output.assetsHashes[key]);
+    }
+    const entryKey = toPosix(relative(repoRoot, output.filePath));
+    add(entryKey, output.filePath, output.assetsHashes[entryKey]);
+  }
+  for (const envFile of ENV_FILES) {
+    const source = join(ctx.projectDir, envFile);
+    if (existsSync(source)) {
+      add(toPosix(relative(repoRoot, source)), source);
+    }
+  }
+  return staging;
+}
+function collectStaticFiles(ctx) {
+  const { repoRoot } = ctx;
+  const basePath = ctx.config.basePath || "";
+  const staticFiles = /* @__PURE__ */ new Map();
+  const pagesDir = join(ctx.distDir, "server", "pages") + sep;
+  for (const output of ctx.outputs.staticFiles) {
+    const key = toPosix(relative(repoRoot, output.filePath));
+    const pathnames = routablePathnames(
+      output.pathname,
+      basePath,
+      output.filePath.startsWith(pagesDir)
+    );
+    for (const pathname of pathnames) {
+      const existing = staticFiles.get(pathname);
+      if (existing !== void 0 && existing !== key) {
+        throw new Error(
+          `${LOG_PREFIX} Two static files claim the pathname "${pathname}" ("${existing}" and "${key}"). Dispatch cannot choose between them.`
+        );
+      }
+      staticFiles.set(pathname, key);
+    }
+  }
+  return Object.fromEntries(
+    [...staticFiles].sort(([a], [b]) => a < b ? -1 : 1)
+  );
+}
+function routablePathnames(pathname, basePath, fromPagesRouter) {
+  if (!fromPagesRouter || pathname !== `${basePath}/index`) {
+    return [pathname];
+  }
+  return [basePath || "/", pathname];
+}
+function stageServedStaticFiles(ctx, staging) {
+  const { repoRoot, distDir } = ctx;
+  const clientStaticDir = join(distDir, "static") + sep;
+  for (const output of ctx.outputs.staticFiles) {
+    const servedByS3 = output.filePath.startsWith(clientStaticDir) || !output.filePath.startsWith(distDir + sep);
+    if (servedByS3) {
+      continue;
+    }
+    const key = toPosix(relative(repoRoot, output.filePath));
+    assertStagingKey(key, output.filePath);
+    staging.set(key, output.filePath);
+  }
+}
+function assertBuildCwd(ctx, buildCwd) {
+  const cwd = resolve(buildCwd);
+  if (cwd === resolve(ctx.projectDir)) {
+    return;
+  }
+  throw new Error(
+    `${LOG_PREFIX} \`next build\` must run from the Next.js project directory. It ran from "${cwd}" with the project at "${ctx.projectDir}". Next.js bakes the relative path between those two into every built entrypoint, and cdk-nextjs cannot reproduce that layout in the deployment package. Change directory first (\`cd ${relative(cwd, ctx.projectDir) || "."} && next build\`) instead of passing the directory as an argument; in a monorepo, run the app's own build script from its directory (e.g. \`pnpm --filter <app> build\`, which runs in the package directory).`
+  );
+}
+function addEntrypoint(entrypoints, repoRoot, output, type, basePath) {
+  const filePath = toPosix(relative(repoRoot, output.filePath));
+  const pathnames = routablePathnames(
+    output.pathname,
+    basePath,
+    type === "page"
+  );
+  for (const pathname of pathnames) {
+    const existing = entrypoints[pathname];
+    if (existing && existing.filePath !== filePath) {
+      throw new Error(
+        `${LOG_PREFIX} Two build outputs claim the pathname "${pathname}" ("${existing.filePath}" and "${filePath}"). Dispatch cannot choose between them.`
+      );
+    }
+    entrypoints[pathname] = { id: output.id, filePath, type };
+  }
+}
+function addPrerenderPathnames(entrypoints, prerenders, dynamicRoutes, basePath, dataRoutePrefix) {
+  const matchers = dynamicRoutes.map((route) => ({
+    regex: new RegExp(route.sourceRegex, "i"),
+    gated: Boolean(route.has?.length || route.missing?.length)
+  }));
+  const matchingRules = (pathname) => matchers.filter(({ regex }) => regex.test(pathname));
+  const onlyGatedRulesMatch = (pathname) => {
+    const matched = matchingRules(pathname);
+    return matched.length > 0 && matched.every(({ gated }) => gated);
+  };
+  const nothingUngatedMatches = (pathname) => matchingRules(pathname).every(({ gated }) => gated);
+  const orphans = [];
+  for (const prerender of prerenders) {
+    const { pathname } = prerender;
+    if (entrypoints[pathname]) {
+      continue;
+    }
+    const isTemplate = pathname.includes("[");
+    const isDataRoute = pathname.startsWith(dataRoutePrefix) && pathname.endsWith(".json");
+    const reachable = isDataRoute ? nothingUngatedMatches(pathname) : onlyGatedRulesMatch(pathname);
+    if (!isTemplate && !reachable) {
+      continue;
+    }
+    const suffixes = pathname.endsWith(".rsc") ? [".rsc", ""] : [""];
+    const owner = suffixes.flatMap((suffix) => [
+      `${basePath}${prerender.route}${suffix}`,
+      `${prerender.route}${suffix}`
+    ]).map((key) => entrypoints[key]).find(Boolean);
+    if (!owner) {
+      orphans.push(`${pathname} (route: "${prerender.route}")`);
+      continue;
+    }
+    entrypoints[pathname] = {
+      id: prerender.id,
+      filePath: owner.filePath,
+      type: owner.type
+    };
+  }
+  if (orphans.length > 0) {
+    console.warn(
+      `${LOG_PREFIX} ${orphans.length} prerender pathname(s) have no matching route entrypoint and will 404: ${orphans.slice(0, 5).join(", ")}${orphans.length > 5 ? `, and ${orphans.length - 5} more` : ""}.`
+    );
+  }
+}
+function buildMiddleware(repoRoot, middleware) {
+  if (!middleware) {
+    return null;
+  }
+  return {
+    id: middleware.id,
+    filePath: toPosix(relative(repoRoot, middleware.filePath))
+  };
+}
+var STAGING_CONCURRENCY = 32;
+async function stageFiles(staging, stagingDir) {
+  const planned = [...staging];
+  const links = new Array(
+    planned.length
+  );
+  let nextEntry = 0;
+  const worker = async () => {
+    while (nextEntry < planned.length) {
+      const index = nextEntry++;
+      const [key, source] = planned[index];
+      const linkTarget = await readlink(source).catch(() => null);
+      if (linkTarget !== null) {
+        links[index] = [key, source, linkTarget];
+        continue;
+      }
+      const dest = join(stagingDir, key);
+      await mkdir(dirname(dest), { recursive: true });
+      await copyFile(source, dest);
+    }
+  };
+  await Promise.all(
+    Array.from(
+      { length: Math.min(STAGING_CONCURRENCY, planned.length) },
+      worker
+    )
+  );
+  for (const link of links) {
+    if (link === void 0) {
+      continue;
+    }
+    const [key, source, linkTarget] = link;
+    const dest = join(stagingDir, key);
+    if (existsSync(dest)) {
+      continue;
+    }
+    await mkdir(dirname(dest), { recursive: true });
+    const resolved = resolve(dirname(dest), linkTarget);
+    if (resolved === stagingDir || resolved.startsWith(stagingDir + sep)) {
+      await symlink(linkTarget, dest);
+    } else {
+      await cp(source, dest, { recursive: true, dereference: true });
+    }
+  }
+}
+async function addRuntimeNextClosure(ctx, staging, imageStaging) {
+  const nextRequire = createRequire(
+    join(ctx.projectDir, "cdk-nextjs-next-resolver.cjs")
+  );
+  let entries;
+  let imageEntries;
+  try {
+    entries = RUNTIME_NEXT_MODULES.map(
+      (specifier) => nextRequire.resolve(specifier)
+    );
+    imageEntries = IMAGE_NEXT_MODULES.map(
+      (specifier) => nextRequire.resolve(specifier)
+    );
+  } catch (cause) {
+    console.warn(
+      `${LOG_PREFIX} Could not resolve next's image optimizer from "${ctx.projectDir}" (${cause.message}). Requests to /_next/image will fail at runtime.`
+    );
+    return;
+  }
+  const nextPackage = nextRequire.resolve("next/package.json");
+  try {
+    entries.push(createRequire(nextPackage).resolve("@next/env"));
+  } catch (cause) {
+    throw new Error(
+      `${LOG_PREFIX} Could not resolve "@next/env" from the app's \`next\`, which the cdk-nextjs runtime uses to load .env files.`,
+      { cause }
+    );
+  }
+  let nodeFileTrace;
+  try {
+    ({ nodeFileTrace } = nextRequire(NEXT_FILE_TRACER));
+  } catch (cause) {
+    throw new Error(
+      `${LOG_PREFIX} Could not load "${NEXT_FILE_TRACER}", which cdk-nextjs uses to stage the \`next\` files its image optimizer requires. This Next.js version may have moved it; please open an issue.`,
+      { cause }
+    );
+  }
+  const add = (fileList2, target) => {
+    for (const traced of fileList2) {
+      const key = toPosix(traced);
+      if (target.has(key)) {
+        continue;
+      }
+      const source = join(ctx.repoRoot, traced);
+      assertStagingKey(key, source);
+      target.set(key, source);
+    }
+  };
+  add(
+    (await nodeFileTrace(imageEntries, { base: ctx.repoRoot })).fileList,
+    imageStaging
+  );
+  const { fileList } = await nodeFileTrace(entries, { base: ctx.repoRoot });
+  const nextEnvLink = join(dirname(nextPackage), "..", "@next", "env");
+  if (lstatSync(nextEnvLink, { throwIfNoEntry: false })?.isSymbolicLink()) {
+    fileList.add(relative(realpathSync(ctx.repoRoot), nextEnvLink));
+  }
+  add(fileList, staging);
+}
+function addRequiredServerFiles(ctx, staging) {
+  const source = join(ctx.distDir, "required-server-files.json");
+  const key = toPosix(relative(ctx.repoRoot, source));
+  if (staging.has(key) || !existsSync(source)) {
+    return;
+  }
+  assertStagingKey(key, source);
+  staging.set(key, source);
+}
+function assertStagingKey(key, source) {
+  if (key === "" || key.startsWith("/") || key.startsWith("..")) {
+    throw new Error(
+      `${LOG_PREFIX} Build output asset "${source}" resolves to the staging key "${key}", which is outside the deployment root. Set \`outputFileTracingRoot\` so all traced files live under one root.`
+    );
+  }
+  if (key === RUNTIME_DIR_NAME || key.startsWith(`${RUNTIME_DIR_NAME}/`)) {
+    throw new Error(
+      `${LOG_PREFIX} Build output asset "${source}" resolves to the staging key "${key}", but "${RUNTIME_DIR_NAME}/" is reserved for cdk-nextjs's own runtime files.`
+    );
+  }
+}
+function toPosix(path) {
+  return sep === "/" ? path : path.split(sep).join("/");
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort();
+}
+
+// src/adapter/init-cache.ts
+var import_debug = __toESM(require_src());
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { CachedRouteKind as CachedRouteKind2 } from "next/dist/server/response-cache/index.js";
+
+// src/adapter/cache-kinds.ts
+import { CachedRouteKind } from "next/dist/server/response-cache/index.js";
+function cacheKindResolver(outputs) {
+  const kindById = /* @__PURE__ */ new Map();
+  for (const { id } of outputs.pages) {
+    kindById.set(id, CachedRouteKind.PAGES);
+  }
+  for (const { id } of outputs.appPages) {
+    kindById.set(id, CachedRouteKind.APP_PAGE);
+  }
+  for (const { id } of outputs.appRoutes) {
+    kindById.set(id, CachedRouteKind.APP_ROUTE);
+  }
+  return (variants) => {
+    const source = variants.html ?? variants.rsc ?? variants.data ?? variants.segments[0];
+    return source ? kindById.get(source.parentOutputId) : void 0;
+  };
+}
 
 // src/adapter/cache-utils.ts
 function preprocessValue(value) {
@@ -807,7 +2081,7 @@ function preprocessValue(value) {
   if (Buffer.isBuffer(value)) {
     return {
       __type: "Buffer",
-      data: Array.from(value)
+      base64: value.toString("base64")
     };
   }
   if (value instanceof Map) {
@@ -836,140 +2110,222 @@ function serializeCacheValue(value) {
   const processed = preprocessValue(value);
   return JSON.stringify(processed);
 }
+function prerenderPathToCacheKey(pathname, basePath) {
+  const route = (hasPathPrefix(pathname, basePath) ? pathname.slice(basePath.length) : pathname).replace(/^\/+/, "");
+  return route === "" ? "index" : route;
+}
+var INDEX_SUFFIX = "/index";
+var PAGES_DATA_PATHNAME = /^(.*)\/_next\/data\/[^/]+\/(.+)\.json$/;
+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 = /* @__PURE__ */ new Map();
+  const variantsFor = (base) => {
+    let variants = groups.get(base);
+    if (!variants) {
+      variants = { segments: [] };
+      groups.set(base, variants);
+    }
+    return variants;
+  };
+  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;
+}
+var NON_CACHEABLE_APP_PAGE_HEADERS = /* @__PURE__ */ new Set([
+  "content-type",
+  "vary",
+  "x-nextjs-prerender",
+  "x-nextjs-postponed"
+]);
+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;
+}
+var NEXT_CACHE_TAGS_HEADER = "x-next-cache-tags";
+function headerTags(value) {
+  const headers = value?.headers;
+  const header = headers?.[NEXT_CACHE_TAGS_HEADER];
+  return typeof header === "string" ? header.split(",").filter(Boolean) : [];
+}
+var INIT_CACHE_TAG_MANIFEST = "_cdk-nextjs-tag-manifest.json";
 
-// src/adapter/adapter.mts
-var import_debug = __toESM(require_src(), 1);
+// src/adapter/init-cache.ts
 var debug = (0, import_debug.default)("cdk-nextjs:adapter");
-var adapter = {
-  name: "cdk-nextjs-adapter",
-  async modifyConfig(config, { phase }) {
-    if (phase === "phase-production-build") {
-      return {
-        ...config,
-        output: "standalone",
-        cacheHandler: config.cacheHandler ? config.cacheHandler : fileURLToPath(import.meta.resolve("cdk-nextjs/cache-handler")),
-        images: {
-          ...config.images,
-          customCacheHandler: config.images.customCacheHandler ? config.images.customCacheHandler : true
-          // TODO: remove in Next.js 17
-        }
-      };
-    }
-    return config;
-  },
-  async onBuildComplete(ctx) {
-    const cacheDir = process.env.CDK_NEXTJS_INIT_CACHE_DIR || join(ctx.distDir, "cdk-nextjs-init-cache");
-    await mkdir(cacheDir, { recursive: true });
-    debug(`Init cache directory: ${cacheDir}`);
-    const prerenderGroups = groupPrerendersByBasePath(ctx.outputs.prerenders);
-    debug(`Prerender groups: ${prerenderGroups.size} groups`);
-    const prerenderPaths = Array.from(prerenderGroups.keys());
-    const routeToCacheKind = getRouteToCacheKindMap(
-      ctx.outputs,
-      prerenderPaths
-    );
-    debug(`Route mapping: ${routeToCacheKind.size} routes`);
-    for (const [basePath, prerenders] of prerenderGroups) {
-      try {
-        if (basePath.includes("[")) {
-          debug(`SKIP: Dynamic route template ${basePath}`);
-          continue;
-        }
-        const kind = routeToCacheKind.get(basePath);
-        if (!kind) {
-          debug(`SKIP: No route kind found for ${basePath}`);
+async function writeInitCache(ctx, cacheDir) {
+  await mkdir2(cacheDir, { recursive: true });
+  debug(`Init cache directory: ${cacheDir}`);
+  const prerenderGroups = groupPrerenders(ctx.outputs.prerenders);
+  debug(`Prerender groups: ${prerenderGroups.size} groups`);
+  const cacheKindOf = cacheKindResolver(ctx.outputs);
+  const tagManifest = {};
+  for (const [basePath, variants] of prerenderGroups) {
+    try {
+      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;
+      }
+      let cacheEntry;
+      if (kind === CachedRouteKind2.APP_PAGE) {
+        const html = await readPrerenderAsText(htmlPrerender);
+        if (!html) {
+          debug(`SKIP: No HTML content for APP_PAGE ${basePath}`);
           continue;
         }
-        debug(`Processing ${basePath} (${kind})`);
-        const htmlPrerender = prerenders.find((p) => p.pathname === basePath);
-        const rscPrerender = prerenders.find(
-          (p) => p.pathname === `${basePath}.rsc`
+        const rscData = await readPrerenderAsBuffer(rscPrerender);
+        const segmentData = await getSegmentData(segmentPrerenders);
+        const headers = appPageCacheHeaders(
+          htmlPrerender?.fallback?.initialHeaders || rscPrerender?.fallback?.initialHeaders || {}
         );
-        const segmentPrerenders = prerenders.filter(
-          (p) => p.pathname.includes(".segments/")
-        );
-        if (!htmlPrerender && !rscPrerender) {
-          debug(`SKIP: No prerender files found for ${basePath}`);
+        cacheEntry = {
+          lastModified: Date.now(),
+          value: {
+            kind: CachedRouteKind2.APP_PAGE,
+            html,
+            rscData,
+            headers,
+            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 === CachedRouteKind2.APP_ROUTE) {
+        const body = await readPrerenderAsBuffer(htmlPrerender);
+        if (!body) {
+          debug(`SKIP: No body content for APP_ROUTE ${basePath}`);
           continue;
         }
-        let cacheEntry;
-        if (kind === CachedRouteKind.APP_PAGE) {
-          const html = await readPrerenderAsText(htmlPrerender);
-          if (!html) {
-            debug(`SKIP: No HTML content for APP_PAGE ${basePath}`);
-            continue;
-          }
-          const rscData = await readPrerenderAsBuffer(rscPrerender);
-          const segmentData = await getSegmentData(segmentPrerenders);
-          const headers = htmlPrerender?.fallback?.initialHeaders || rscPrerender?.fallback?.initialHeaders || {};
-          cacheEntry = {
-            lastModified: Date.now(),
-            value: {
-              kind: CachedRouteKind.APP_PAGE,
-              html,
-              rscData,
-              headers,
-              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 === CachedRouteKind.APP_ROUTE) {
-          const body = await readPrerenderAsBuffer(htmlPrerender);
-          if (!body) {
-            debug(`SKIP: No body content for APP_ROUTE ${basePath}`);
-            continue;
+        const headers = htmlPrerender?.fallback?.initialHeaders || {};
+        cacheEntry = {
+          lastModified: Date.now(),
+          value: {
+            kind: CachedRouteKind2.APP_ROUTE,
+            body,
+            headers,
+            status: htmlPrerender?.fallback?.initialStatus || 200
           }
-          const headers = htmlPrerender?.fallback?.initialHeaders || {};
-          cacheEntry = {
-            lastModified: Date.now(),
-            value: {
-              kind: CachedRouteKind.APP_ROUTE,
-              body,
-              headers,
-              status: htmlPrerender?.fallback?.initialStatus || 200
-            }
-          };
-        } else {
-          debug(`SKIP: Unsupported route kind ${kind} for ${basePath}`);
+        };
+      } else if (kind === CachedRouteKind2.PAGES) {
+        const initialStatus = htmlPrerender?.fallback?.initialStatus;
+        if (initialStatus !== void 0 && initialStatus !== 200) {
+          debug(
+            `SKIP: PAGES ${basePath} prerendered with status ${initialStatus} (build-time notFound)`
+          );
           continue;
         }
-        const cacheKey = basePath === "/" ? "index" : basePath.replace(/^\//, "").replace(/\//g, "/");
-        const cacheFilePath = join(cacheDir, `${cacheKey}.json`);
-        await mkdir(
-          join(cacheDir, cacheKey.split("/").slice(0, -1).join("/")),
-          {
-            recursive: true
+        const html = await readPrerenderAsText(htmlPrerender);
+        if (!html) {
+          debug(`SKIP: No HTML content for PAGES ${basePath}`);
+          continue;
+        }
+        const pageDataJson = await readPrerenderAsText(dataPrerender);
+        cacheEntry = {
+          lastModified: Date.now(),
+          value: {
+            kind: CachedRouteKind2.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: void 0,
+            status: void 0
           }
-        );
-        await writeFile(cacheFilePath, serializeCacheValue(cacheEntry));
-        debug(`Created cache entry: ${cacheFilePath}`);
-      } catch (error) {
-        console.error(`Error processing prerender group ${basePath}:`, error);
+        };
+      } else {
+        debug(`SKIP: Unsupported route kind ${kind} for ${basePath}`);
+        continue;
       }
+      const cacheKey = prerenderPathToCacheKey(
+        basePath,
+        ctx.config.basePath || ""
+      );
+      const cacheFilePath = join2(cacheDir, `${cacheKey}.json`);
+      await mkdir2(join2(cacheDir, cacheKey.split("/").slice(0, -1).join("/")), {
+        recursive: true
+      });
+      await writeFile2(cacheFilePath, serializeCacheValue(cacheEntry));
+      for (const tag of headerTags(cacheEntry.value)) {
+        (tagManifest[tag] ??= []).push(cacheKey);
+      }
+      debug(`Created cache entry: ${cacheFilePath}`);
+    } catch (error) {
+      console.error(`Error processing prerender group ${basePath}:`, error);
     }
   }
-};
-var adapter_default = adapter;
+  const taggedKeys = Object.keys(tagManifest).length;
+  if (taggedKeys > 0) {
+    await writeFile2(
+      join2(cacheDir, INIT_CACHE_TAG_MANIFEST),
+      JSON.stringify(tagManifest)
+    );
+    debug(`Wrote ${INIT_CACHE_TAG_MANIFEST} with ${taggedKeys} tags`);
+  }
+}
 async function readPrerenderAsText(prerender) {
-  if (prerender?.fallback && "filePath" in prerender.fallback && prerender.fallback.filePath && existsSync(prerender.fallback.filePath)) {
-    return await readFile(prerender.fallback.filePath, "utf-8");
+  if (prerender?.fallback && "filePath" in prerender.fallback && prerender.fallback.filePath && existsSync2(prerender.fallback.filePath)) {
+    return readFile(prerender.fallback.filePath, "utf-8");
   }
   return void 0;
 }
 async function readPrerenderAsBuffer(prerender) {
-  if (prerender?.fallback && "filePath" in prerender.fallback && prerender.fallback.filePath && existsSync(prerender.fallback.filePath)) {
-    return await readFile(prerender.fallback.filePath);
+  if (prerender?.fallback && "filePath" in prerender.fallback && prerender.fallback.filePath && existsSync2(prerender.fallback.filePath)) {
+    return readFile(prerender.fallback.filePath);
   }
   return void 0;
 }
 async function getSegmentData(segmentPrerenders) {
   const segmentData = /* @__PURE__ */ new Map();
   for (const segmentPrerender of segmentPrerenders) {
-    if (segmentPrerender.fallback && "filePath" in segmentPrerender.fallback && segmentPrerender.fallback.filePath && existsSync(segmentPrerender.fallback.filePath)) {
+    if (segmentPrerender.fallback && "filePath" in segmentPrerender.fallback && segmentPrerender.fallback.filePath && existsSync2(segmentPrerender.fallback.filePath)) {
       const segmentContent = await readFile(segmentPrerender.fallback.filePath);
       const segmentName = "/" + segmentPrerender.pathname.split(".segments/")[1].replace(/\.segment\.rsc$/, "");
       segmentData.set(segmentName, segmentContent);
@@ -977,68 +2333,75 @@ async function getSegmentData(segmentPrerenders) {
   }
   return segmentData;
 }
-function getRouteToCacheKindMap(outputs, prerenderPaths) {
-  const routeToCacheKind = /* @__PURE__ */ new Map();
-  const matchesDynamicRoute = (path, pattern) => {
-    if (!pattern.includes("[")) {
-      return path === pattern;
+
+// src/adapter/adapter.mts
+var import_debug2 = __toESM(require_src(), 1);
+var debug2 = (0, import_debug2.default)("cdk-nextjs:adapter");
+var adapter = {
+  name: "cdk-nextjs-adapter",
+  async modifyConfig(config, { phase, nextVersion }) {
+    if (phase === "phase-production-build") {
+      assertSupportedNextVersion(nextVersion);
+      return {
+        ...config,
+        // No `output: "standalone"`. `onBuildComplete` stages the deployment
+        // root from the same NFT traces `writeStandaloneDirectory` would have
+        // used, so the two are alternatives rather than layers — `next build`
+        // says as much itself, immediately above the `onBuildComplete` call:
+        // "in the future `output: standalone` might not be allowed if an adapter
+        // with `onBuildComplete` is configured."
+        cacheHandler: config.cacheHandler ? config.cacheHandler : fileURLToPath(import.meta.resolve("cdk-nextjs/cache-handler")),
+        cacheHandlers: useCacheHandlers(config.cacheHandlers),
+        images: {
+          ...config.images,
+          customCacheHandler: config.images.customCacheHandler ? config.images.customCacheHandler : true
+          // TODO: remove in Next.js 17
+        }
+      };
     }
-    const patternParts = pattern.split("/");
-    const pathParts = path.split("/");
-    if (patternParts.length !== pathParts.length) {
-      return false;
+    if (phase === "phase-production-server") {
+      return {
+        ...config,
+        cacheHandlers: useCacheHandlers(config.cacheHandlers)
+      };
     }
-    return patternParts.every((patternPart, i) => {
-      if (patternPart.startsWith("[") && patternPart.endsWith("]")) {
-        return true;
-      }
-      return patternPart === pathParts[i];
-    });
-  };
-  for (const appPage of outputs.appPages) {
-    routeToCacheKind.set(appPage.pathname, CachedRouteKind.APP_PAGE);
-    if (appPage.pathname.includes("[")) {
-      for (const prerenderPath of prerenderPaths) {
-        if (matchesDynamicRoute(prerenderPath, appPage.pathname)) {
-          routeToCacheKind.set(prerenderPath, CachedRouteKind.APP_PAGE);
-        }
-      }
+    return config;
+  },
+  async onBuildComplete(ctx) {
+    const { manifest, adapterDir, stagedGroups } = await writeBuildOutputs(ctx);
+    const entrypointCount = Object.keys(manifest.entrypoints).length;
+    for (const group of stagedGroups) {
+      const routes = manifest.groups?.[group.name];
+      console.log(
+        `${LOG_PREFIX} Staged ${group.fileCount} files for ${routes ? `${routes.length} of ${entrypointCount}` : entrypointCount} entrypoints in ${group.path}`
+      );
     }
+    debug2(`Adapter output directory: ${adapterDir}`);
+    const cacheDir = process.env.CDK_NEXTJS_INIT_CACHE_DIR || join3(ctx.distDir, "cdk-nextjs-init-cache");
+    await writeInitCache(ctx, cacheDir);
   }
-  for (const appRoute of outputs.appRoutes) {
-    routeToCacheKind.set(appRoute.pathname, CachedRouteKind.APP_ROUTE);
-    if (appRoute.pathname.includes("[")) {
-      for (const prerenderPath of prerenderPaths) {
-        if (matchesDynamicRoute(prerenderPath, appRoute.pathname)) {
-          routeToCacheKind.set(prerenderPath, CachedRouteKind.APP_ROUTE);
-        }
-      }
-    }
+};
+var adapter_default = adapter;
+var MIN_NEXT_VERSION = [16, 3];
+function assertSupportedNextVersion(nextVersion) {
+  const match = /^(\d+)\.(\d+)\./.exec(nextVersion ?? "");
+  if (!match) {
+    return;
   }
-  return routeToCacheKind;
-}
-function groupPrerendersByBasePath(prerenders) {
-  const prerenderGroups = /* @__PURE__ */ new Map();
-  for (const prerender of prerenders) {
-    let basePath = prerender.pathname;
-    if (basePath.endsWith(".rsc")) {
-      basePath = basePath.replace(/\.rsc$/, "");
-    }
-    if (basePath.includes(".segments/")) {
-      basePath = basePath.split(".segments/")[0];
-    }
-    if (basePath === "/index") {
-      basePath = "/";
-    }
-    if (!prerenderGroups.has(basePath)) {
-      prerenderGroups.set(basePath, []);
-    }
-    const group = prerenderGroups.get(basePath);
-    if (group) {
-      group.push(prerender);
-    }
+  const [major, minor] = [Number(match[1]), Number(match[2])];
+  const [minMajor, minMinor] = MIN_NEXT_VERSION;
+  if (major < minMajor || major === minMajor && minor < minMinor) {
+    throw new Error(
+      `${LOG_PREFIX} Next.js ${nextVersion} is not supported: cdk-nextjs needs Next.js ${minMajor}.${minMinor} or higher.`
+    );
   }
-  return prerenderGroups;
+}
+function useCacheHandlers(configured) {
+  return {
+    ...configured,
+    default: configured?.default || fileURLToPath(import.meta.resolve("cdk-nextjs/cache-handlers/default")),
+    remote: configured?.remote || fileURLToPath(import.meta.resolve("cdk-nextjs/cache-handlers/remote"))
+  };
 }
 export {
   adapter_default as default